File manager

3

iR�V�`�@s�dd
lZyddl
mZ
Wn ek
r8


ddlmZ
YnXdd
lZddlmZ
ddlm	Z	m
Z
mZmZ
dZ
ejd�
ZddlmZmZmZmZmZ
ddlmZ
Gd	d
�d
�ZGdd�d�ZGd
d�de�ZGdd�de�Zd
S)�N)
�RLock)
�process_introspection_data)�
DBusException�IntrospectionParserException�MissingErrorHandlerException�MissingReplyHandlerExceptionZrestructuredtextzdbus.proxies)�BUS_DAEMON_IFACE�BUS_DAEMON_NAME�BUS_DAEMON_PATH�INTROSPECTABLE_IFACE�
LOCAL_PATH)
�is_py2c@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�_DeferredMethodzXA proxy method which will only get called once we have its
    introspection reply.
    cCs|
|_|
j
|_
||_||_dS)
N)�
_proxy_method�_method_name�_append�_block)�self�proxy_method�append�block�r�/usr/lib64/python3.6/proxies.py�__init__6s


z_DeferredMethod.__init__c
Os@d
|ks|jdd�r(|j
|j|
|�
dS|j�
|j|
|�
SdS)N�
reply_handler�ignore_replyF)�getrrr)r�args�keywordsrrr�__call__=s



z_DeferredMethod.__call__c
Os|j|j
|
|�
dS)
N)rr)rrrrrr�
call_asyncHs
z_DeferredMethod.call_asyncN)�__name__�
__module__�__qualname__�__doc__rrr rrrrr2s
rc@s(eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�_ProxyMethodz�A proxy method.

    Typically a member of a ProxyObject. Calls to the
    method produce messages that travel over the Bus and are routed
    to a specific named Service.
    cCsX|tkrt
d
t�
�
|
|_||_||_||_tj|�

||_|dk	rNtj	|�

||_
dS)Nz1Methods may not be called on the reserved path %s)rr�_proxy�_connection�_named_service�_object_path�_dbus_bindingsZvalidate_member_namerZvalidate_interface_name�_dbus_interface)r�proxyZ
connection�bus_name�object_pathZmethod_nameZifacerrrrSs








z_ProxyMethod.__init__c
		Os
|jd
d�}|jdd�}|jdd�}|jdd�}|dk	s@|dk	rl|dkrPt
��
n|dkr`t��
n|rltd�
�
|jd|j�}|dkr�|dkr�|j}n|d|j}|jjj|d�}|s�|dk	r�|j	j
|j|j||j||
||f|�

n |j	j
|j|j||j||
f|�
SdS)	Nr�
error_handlerrF�	signaturez6ignore_reply and reply_handler cannot be used together�dbus_interface�
.)�poprr�	TypeErrorr+rr&�_introspect_method_maprr'r r(r)Z
call_blocking)	rrrrr/rr0r1�keyrrrrgsD




























z_ProxyMethod.__call__c
	Os�|jd
d�}|jdd�}|jdd�}|jd|j
�}|dkrd|rN|d|j}n|j}|jjj|d�}|jj|j|j	||j||
||f|�

dS)Nrr/r0r1r2)
r3r+rr&r5rr'r r(r))rrrrr/r0r1r6rrrr �s$














z_ProxyMethod.call_asyncN)r!r"r#r$rrr rrrrr%Ls
,r%c@s�eZ
dZd
ZeZeZdZdZ	dZ
d%dd	�
Zed
d�ddd�Z
ed
d�ddd�Zedd�ddd�Zd&dd�
Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd'd!d"�
Zd#d$�ZeZdS)(�ProxyObjectz�A proxy to the remote Object.

    A ProxyObject is provided by the Bus. ProxyObjects
    have member functions, and can be called like normal Python objects.
    r
�
�NTFc
Ks<
|jd
d�}|dk	rB|
dk	r$t
d�
�
|}
ddlm}
|dtdd�
|jd	d�}	|	dk	r�|dk	rft
d
�
�
|	}ddlm}
|dtdd�
|r�t
dd
j|j��
�
�
|r�|
j�
|
|_|dk	r�t	j
|�

||_|_t	j
|�

||_|s�|
j|�
|_d|_g|_i|_t�|_|�
s|jtk�
r&|j|_n|j|_|j�|_dS)a�Initialize the proxy object.

        :Parameters:
            `conn` : `dbus.connection.Connection`
                The bus or connection on which to find this object.
                The keyword argument `bus` is a deprecated alias for this.
            `bus_name` : str
                A bus name for the application owning the object, to be used
                as the destination for method calls and the sender for
                signal matches. The keyword argument ``named_service`` is a
                deprecated alias for this.
            `object_path` : str
                The object path at which the application exports the object
            `introspect` : bool
                If true (default), attempt to introspect the remote
                object to find out supported methods and their signatures
            `follow_name_owner_changes` : bool
                If true (default is false) and the `bus_name` is a
                well-known name, follow ownership changes for that name
        �busNz%conn and bus cannot both be specifiedr
)
�warnz`Passing the bus parameter to ProxyObject by name is deprecated: please use positional parametersr9)
�
stacklevel�
named_servicez3bus_name and named_service cannot both be specifiedzjPassing the named_service parameter to ProxyObject by name is deprecated: please use positional parametersz>ProxyObject.__init__ does not take these keyword arguments: %sz, )r3r4�warningsr;�DeprecationWarning�join�keysZ_require_main_loop�_busr*Zvalidate_bus_namer(�_requested_bus_nameZvalidate_object_path�__dbus_object_path__Zactivate_name_owner�_pending_introspect�_pending_introspect_queuer5r�_introspect_lockr� INTROSPECT_STATE_DONT_INTROSPECT�_introspect_state�'INTROSPECT_STATE_INTROSPECT_IN_PROGRESS�_Introspect)
rZconnr-r.Z
introspectZfollow_name_owner_changes�kwargsr:r;r=rrrr�sJ






















zProxyObject.__init__c


Cs|jS)
N)
r()
rrrr�<lambda>
szProxyObject.<lambda>a�The bus name to which this proxy is bound. (Read-only,
            may change.)

            If the proxy was instantiated using a unique name, this property
            is that unique name.

            If the proxy was instantiated with a well-known name and with
            ``follow_name_owner_changes`` set false (the default), this
            property is the unique name of the connection that owned that
            well-known name when the proxy was instantiated, which might
            not actually own the requested well-known name any more.

            If the proxy was instantiated with a well-known name and with
            ``follow_name_owner_changes`` set true, this property is that
            well-known name.
            c


Cs|jS)
N)
rC)
rrrrrM
sz[The bus name which was requested when this proxy was
            instantiated.
            c


Cs|jS)
N)
rD)
rrrrrM$
szThe object-path of this proxy.cKs"|jj
|f
|
||j|jd
�|��
S)axArrange for the given function to be called when the given signal
        is received.

        :Parameters:
            `signal_name` : str
                The name of the signal
            `handler_function` : callable
                A function to be called when the signal is emitted by
                the remote object. Its positional arguments will be the
                arguments of the signal; optionally, it may be given
                keyword arguments as described below.
            `dbus_interface` : str
                Optional interface with which to qualify the signal name.
                If None (the default) the handler will be called whenever a
                signal of the given member name is received, whatever
                its interface.
        :Keywords:
            `utf8_strings` : bool
                If True, the handler function will receive any string
                arguments as dbus.UTF8String objects (a subclass of str
                guaranteed to be UTF-8). If False (default) it will receive
                any string arguments as dbus.String objects (a subclass of
                unicode).
            `byte_arrays` : bool
                If True, the handler function will receive any byte-array
                arguments as dbus.ByteArray objects (a subclass of str).
                If False (default) it will receive any byte-array
                arguments as a dbus.Array of dbus.Byte (subclasses of:
                a list of ints).
            `sender_keyword` : str
                If not None (the default), the handler function will receive
                the unique name of the sending endpoint as a keyword
                argument with this name
            `destination_keyword` : str
                If not None (the default), the handler function will receive
                the bus name of the destination (or None if the signal is a
                broadcast, as is usual) as a keyword argument with this name.
            `interface_keyword` : str
                If not None (the default), the handler function will receive
                the signal interface as a keyword argument with this name.
            `member_keyword` : str
                If not None (the default), the handler function will receive
                the signal name as a keyword argument with this name.
            `path_keyword` : str
                If not None (the default), the handler function will receive
                the object-path of the sending object as a keyword argument
                with this name
            `message_keyword` : str
                If not None (the default), the handler function will receive
                the `dbus.lowlevel.SignalMessage` as a keyword argument with
                this name.
            `arg...` : unicode or UTF-8 str
                If there are additional keyword parameters of the form
                ``arg``\ *n*, match only signals where the *n*\ th argument
                is the value given for that keyword parameter. As of this time
                only string arguments can be matched (in particular,
                object paths and signatures can't).
        )�signal_namer1r-�path)rBZadd_signal_receiverr(rD)rrN�handler_functionr1rrrr�connect_to_signal0
s<





zProxyObject.connect_to_signalc
	Cs>i}
trd
|
d<|j
j|j|jtddf|j|jfddi
|
��
S)NTZutf8_stringsZ
Introspect�Zrequire_main_loopF)r
rBr r(rDr�_introspect_reply_handler�_introspect_error_handler)rrLrrrrKs
s









zProxyObject._Introspectc
Cs*x|jD]\}
}}|
||�

qWg|_dS)
N)
rF)rrrrrrr�_introspect_execute_queue~
s

z%ProxyObject._introspect_execute_queuecCsp|jj
�
zTyt|
�
|_Wn*tk
rD
}
z|j|�

dSd}~XnX|j|_d|_|j	�
Wd|jj
�
XdS)
N)rG�acquirerr5rrT� INTROSPECT_STATE_INTROSPECT_DONErIrErU�release)r�data�
errrrS�
s










z%ProxyObject._introspect_reply_handlerc
Cshtj
�
tjd
|j|j|
jj|
jj|
�
|j	j
�
z$tjd�

|j|_
d|_|j�
Wd|j	j�
XdS)Nz$Introspect error on %s:%s: %s.%s: %sz'Executing introspect queue due to error)�loggingZbasicConfig�_logger�errorr(rD�	__class__r"r!rGrV�debugrHrIrErUrX)rr]rrrrT�
s












z%ProxyObject._introspect_error_handlerc


Cs4|jj
�
z|jdk	r |jj�
Wd|jj�
XdS)
N)rGrVrErrX)
rrrr�_introspect_block�
s






zProxyObject._introspect_blockc
CsJ|jj
�
z.|j|jkr,|jj|
||f�

n
|
||�

Wd|jj�
XdS)
N)rGrVrIrJrFrrX)r�callbackrrLrrr�_introspect_add_to_queue�
s




z$ProxyObject._introspect_add_to_queuecCs,|
jd
�
r|
j
d
�
rt|
�
�
n
|j|
�
SdS)N�__)�
startswith�endswith�AttributeError�get_dbus_method)r�memberrrr�__getattr__�
s


zProxyObject.__getattr__cCs<|j||j
|j|j|
|�}|j|jkr8|j||j|j�}|S)
a,Return a proxy method representing the given D-Bus method. The
        returned proxy method can be called in the usual way. For instance, ::

            proxy.get_dbus_method("Foo", dbus_interface='com.example.Bar')(123)

        is equivalent to::

            proxy.Foo(123, dbus_interface='com.example.Bar')

        or even::

            getattr(proxy, "Foo")(123, dbus_interface='com.example.Bar')

        However, using `get_dbus_method` is the only way to call D-Bus
        methods with certain awkward names - if the author of a service
        implements a method called ``connect_to_signal`` or even
        ``__getattr__``, you'll need to use `get_dbus_method` to call them.

        For services which follow the D-Bus convention of CamelCaseMethodNames
        this won't be a problem.
        )	�ProxyMethodClassrBr(rDrIrJ�DeferredMethodClassrbr`)rrhr1�retrrrrg�
s






zProxyObject.get_dbus_methodc

Csd
|j|j
|jt|�
fS)Nz&<ProxyObject wrapping %s %s %s at %#x>)rBr(rD�id)
rrrr�__repr__�
s

zProxyObject.__repr__)NNNTF)
N)
N)r!r"r#r$r%rjrrkrHrJrWr�propertyr-�requested_bus_namer.rQrKrUrSrTr`rbrirgrn�__str__rrrrr7�s6





R




C

&r7c@s�eZ
dZd
Zdd�Zedd�ddd�ZeZedd�ddd	�Zed
d�ddd�Z	edd�ddd
�Z
edd�ddd�Zddd�
Zdd�Z
ddd�
Zdd�ZeZdS)�	Interfacez�An interface into a remote object.

    An Interface can be used to wrap ProxyObjects
    so that calls can be routed to their correct
    D-Bus interface.
    cCs$t|
t
�r|
j|_n|
|_||_d
S)a:
Construct a proxy for the given interface on the given object.

        :Parameters:
            `object` : `dbus.proxies.ProxyObject` or `dbus.Interface`
                The remote object or another of its interfaces
            `dbus_interface` : str
                An interface the `object` implements
        N)�
isinstancerr�proxy_object�_objr+)r�objectr1rrrr�
s	



zInterface.__init__c


Cs|jj
S)
N)rur.)
rrrrrMszInterface.<lambda>Nz.The D-Bus object path of the underlying objectc


Cs|jj
S)
N)rur-)
rrrrrMsz:The bus name to which the underlying proxy object is boundc


Cs|jj
S)
N)rurp)
rrrrrM	szGThe bus name which was requested when the underlying object was createdc


Cs|jS)
N)
ru)
rrrrrM
szThe underlying proxy objectc


Cs|jS)
N)
r+)
rrrrrMszThe D-Bus interface representedcKs|s
|j}|j
j|
||f|�
S)
aa
Arrange for a function to be called when the given signal is
        emitted.

        The parameters and keyword arguments are the same as for
        `dbus.proxies.ProxyObject.connect_to_signal`, except that if
        `dbus_interface` is None (the default), the D-Bus interface that
        was passed to the `Interface` constructor is used.
        )r+rurQ)rrNrPr1rrrrrQs



zInterface.connect_to_signalcCs2|
jd
�
r|
j
d
�
rt|
�
�
n|jj|
|j�SdS)Nrc)rdrerfrurgr+)rrhrrrri"s


zInterface.__getattr__cCs|d
kr|j}|j
j|
|�S)a&
Return a proxy method representing the given D-Bus method.

        This is the same as `dbus.proxies.ProxyObject.get_dbus_method`
        except that if `dbus_interface` is None (the default),
        the D-Bus interface that was passed to the `Interface` constructor
        is used.
        N)r+rurg)rrhr1rrrrg(s

zInterface.get_dbus_methodc

Csd
|j|j
t|�
fS)Nz%<Interface %r implementing %r at %#x>)rur+rm)
rrrrrn4s

zInterface.__repr__)
N)
N)r!r"r#r$rror.rDr-rprtr1rQrirgrnrqrrrrrr�
s&










rr)r[Z	threadingr�ImportErrorZdummy_threadingr*Zdbus._expat_introspect_parserrZdbus.exceptionsrrrrZ
__docformat__Z	getLoggerr\rr	r
rrZdbus._compatr
rr%rvr7rrrrrr�<module>s"





`B