<h2>Edit File - proxies.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/site-packages/dbus/proxies.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;"># Copyright (C) 2003-2007 Red Hat Inc. &lt;http://www.redhat.com/&gt;
# Copyright (C) 2003 David Zeuthen
# Copyright (C) 2004 Rob Taylor
# Copyright (C) 2005-2007 Collabora Ltd. &lt;http://www.collabora.co.uk/&gt;
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation
# files (the &quot;Software&quot;), to deal in the Software without
# restriction, including without limitation the rights to use, copy,
# modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

import logging

try:
    from threading import RLock
except ImportError:
    from dummy_threading import RLock

import _dbus_bindings
from dbus._expat_introspect_parser import process_introspection_data
from dbus.exceptions import (
    DBusException, IntrospectionParserException, MissingErrorHandlerException,
    MissingReplyHandlerException)

__docformat__ = &#039;restructuredtext&#039;


_logger = logging.getLogger(&#039;dbus.proxies&#039;)

from _dbus_bindings import (
    BUS_DAEMON_IFACE, BUS_DAEMON_NAME, BUS_DAEMON_PATH, INTROSPECTABLE_IFACE,
    LOCAL_PATH)
from dbus._compat import is_py2


class _DeferredMethod:
    &quot;&quot;&quot;A proxy method which will only get called once we have its
    introspection reply.
    &quot;&quot;&quot;
    def __init__(self, proxy_method, append, block):
        self._proxy_method = proxy_method
        # the test suite relies on the existence of this property
        self._method_name = proxy_method._method_name
        self._append = append
        self._block = block

    def __call__(self, *args, **keywords):
        if (&#039;reply_handler&#039; in keywords or
            keywords.get(&#039;ignore_reply&#039;, False)):
            # defer the async call til introspection finishes
            self._append(self._proxy_method, args, keywords)
            return None
        else:
            # we&#039;re being synchronous, so block
            self._block()
            return self._proxy_method(*args, **keywords)

    def call_async(self, *args, **keywords):
        self._append(self._proxy_method, args, keywords)


class _ProxyMethod:
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;
    def __init__(self, proxy, connection, bus_name, object_path, method_name,
                 iface):
        if object_path == LOCAL_PATH:
            raise DBusException(&#039;Methods may not be called on the reserved &#039;
                                &#039;path %s&#039; % LOCAL_PATH)

        # trust that the proxy, and the properties it had, are OK
        self._proxy          = proxy
        self._connection     = connection
        self._named_service  = bus_name
        self._object_path    = object_path
        # fail early if the method name is bad
        _dbus_bindings.validate_member_name(method_name)
        # the test suite relies on the existence of this property
        self._method_name    = method_name
        # fail early if the interface name is bad
        if iface is not None:
            _dbus_bindings.validate_interface_name(iface)
        self._dbus_interface = iface

    def __call__(self, *args, **keywords):
        reply_handler = keywords.pop(&#039;reply_handler&#039;, None)
        error_handler = keywords.pop(&#039;error_handler&#039;, None)
        ignore_reply = keywords.pop(&#039;ignore_reply&#039;, False)
        signature = keywords.pop(&#039;signature&#039;, None)

        if reply_handler is not None or error_handler is not None:
            if reply_handler is None:
                raise MissingReplyHandlerException()
            elif error_handler is None:
                raise MissingErrorHandlerException()
            elif ignore_reply:
                raise TypeError(&#039;ignore_reply and reply_handler cannot be &#039;
                                &#039;used together&#039;)

        dbus_interface = keywords.pop(&#039;dbus_interface&#039;, self._dbus_interface)

        if signature is None:
            if dbus_interface is None:
                key = self._method_name
            else:
                key = dbus_interface + &#039;.&#039; + self._method_name

            signature = self._proxy._introspect_method_map.get(key, None)

        if ignore_reply or reply_handler is not None:
            self._connection.call_async(self._named_service,
                                        self._object_path,
                                        dbus_interface,
                                        self._method_name,
                                        signature,
                                        args,
                                        reply_handler,
                                        error_handler,
                                        **keywords)
        else:
            return self._connection.call_blocking(self._named_service,
                                                  self._object_path,
                                                  dbus_interface,
                                                  self._method_name,
                                                  signature,
                                                  args,
                                                  **keywords)

    def call_async(self, *args, **keywords):
        reply_handler = keywords.pop(&#039;reply_handler&#039;, None)
        error_handler = keywords.pop(&#039;error_handler&#039;, None)
        signature = keywords.pop(&#039;signature&#039;, None)

        dbus_interface = keywords.pop(&#039;dbus_interface&#039;, self._dbus_interface)

        if signature is None:
            if dbus_interface:
                key = dbus_interface + &#039;.&#039; + self._method_name
            else:
                key = self._method_name
            signature = self._proxy._introspect_method_map.get(key, None)

        self._connection.call_async(self._named_service,
                                    self._object_path,
                                    dbus_interface,
                                    self._method_name,
                                    signature,
                                    args,
                                    reply_handler,
                                    error_handler,
                                    **keywords)


class ProxyObject(object):
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;
    ProxyMethodClass = _ProxyMethod
    DeferredMethodClass = _DeferredMethod

    INTROSPECT_STATE_DONT_INTROSPECT = 0
    INTROSPECT_STATE_INTROSPECT_IN_PROGRESS = 1
    INTROSPECT_STATE_INTROSPECT_DONE = 2

    def __init__(self, conn=None, bus_name=None, object_path=None,
                 introspect=True, follow_name_owner_changes=False, **kwargs):
        &quot;&quot;&quot;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
        &quot;&quot;&quot;
        bus = kwargs.pop(&#039;bus&#039;, None)
        if bus is not None:
            if conn is not None:
                raise TypeError(&#039;conn and bus cannot both be specified&#039;)
            conn = bus
            from warnings import warn
            warn(&#039;Passing the bus parameter to ProxyObject by name is &#039;
                 &#039;deprecated: please use positional parameters&#039;,
                 DeprecationWarning, stacklevel=2)
        named_service = kwargs.pop(&#039;named_service&#039;, None)
        if named_service is not None:
            if bus_name is not None:
                raise TypeError(&#039;bus_name and named_service cannot both be &#039;
                                &#039;specified&#039;)
            bus_name = named_service
            from warnings import warn
            warn(&#039;Passing the named_service parameter to ProxyObject by name &#039;
                 &#039;is deprecated: please use positional parameters&#039;,
                 DeprecationWarning, stacklevel=2)
        if kwargs:
            raise TypeError(&#039;ProxyObject.__init__ does not take these &#039;
                            &#039;keyword arguments: %s&#039;
                            % &#039;, &#039;.join(kwargs.keys()))

        if follow_name_owner_changes:
            # we don&#039;t get the signals unless the Bus has a main loop
            # XXX: using Bus internals
            conn._require_main_loop()

        self._bus = conn

        if bus_name is not None:
            _dbus_bindings.validate_bus_name(bus_name)
        # the attribute is still called _named_service for the moment,
        # for the benefit of telepathy-python
        self._named_service = self._requested_bus_name = bus_name

        _dbus_bindings.validate_object_path(object_path)
        self.__dbus_object_path__ = object_path

        if not follow_name_owner_changes:
            self._named_service = conn.activate_name_owner(bus_name)

        #PendingCall object for Introspect call
        self._pending_introspect = None
        #queue of async calls waiting on the Introspect to return
        self._pending_introspect_queue = []
        #dictionary mapping method names to their input signatures
        self._introspect_method_map = {}

        # must be a recursive lock because block() is called while locked,
        # and calls the callback which re-takes the lock
        self._introspect_lock = RLock()

        if not introspect or self.__dbus_object_path__ == LOCAL_PATH:
            self._introspect_state = self.INTROSPECT_STATE_DONT_INTROSPECT
        else:
            self._introspect_state = self.INTROSPECT_STATE_INTROSPECT_IN_PROGRESS

            self._pending_introspect = self._Introspect()

    bus_name = property(lambda self: self._named_service, None, None,
            &quot;&quot;&quot;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.
            &quot;&quot;&quot;)

    requested_bus_name = property(lambda self: self._requested_bus_name,
            None, None,
            &quot;&quot;&quot;The bus name which was requested when this proxy was
            instantiated.
            &quot;&quot;&quot;)

    object_path = property(lambda self: self.__dbus_object_path__,
            None, None,
            &quot;&quot;&quot;The object-path of this proxy.&quot;&quot;&quot;)

    # XXX: We don&#039;t currently support this because it&#039;s the signal receiver
    # that&#039;s responsible for tracking name owner changes, but it
    # seems a natural thing to add in future.
    #unique_bus_name = property(lambda self: something, None, None,
    #        &quot;&quot;&quot;The unique name of the connection to which this proxy is
    #        currently bound. (Read-only, may change.)
    #        &quot;&quot;&quot;)

    def connect_to_signal(self, signal_name, handler_function, dbus_interface=None, **keywords):
        &quot;&quot;&quot;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&#039;t).
        &quot;&quot;&quot;
        return \
        self._bus.add_signal_receiver(handler_function,
                                      signal_name=signal_name,
                                      dbus_interface=dbus_interface,
                                      bus_name=self._named_service,
                                      path=self.__dbus_object_path__,
                                      **keywords)

    def _Introspect(self):
        kwargs = {}
        if is_py2:
            kwargs[&#039;utf8_strings&#039;] = True
        return self._bus.call_async(self._named_service,
                                    self.__dbus_object_path__,
                                    INTROSPECTABLE_IFACE, &#039;Introspect&#039;, &#039;&#039;, (),
                                    self._introspect_reply_handler,
                                    self._introspect_error_handler,
                                    require_main_loop=False, **kwargs)

    def _introspect_execute_queue(self):
        # FIXME: potential to flood the bus
        # We should make sure mainloops all have idle handlers
        # and do one message per idle
        for (proxy_method, args, keywords) in self._pending_introspect_queue:
            proxy_method(*args, **keywords)
        self._pending_introspect_queue = []

    def _introspect_reply_handler(self, data):
        self._introspect_lock.acquire()
        try:
            try:
                self._introspect_method_map = process_introspection_data(data)
            except IntrospectionParserException as e:
                self._introspect_error_handler(e)
                return

            self._introspect_state = self.INTROSPECT_STATE_INTROSPECT_DONE
            self._pending_introspect = None
            self._introspect_execute_queue()
        finally:
            self._introspect_lock.release()

    def _introspect_error_handler(self, error):
        logging.basicConfig()
        _logger.error(&quot;Introspect error on %s:%s: %s.%s: %s&quot;,
                      self._named_service, self.__dbus_object_path__,
                      error.__class__.__module__, error.__class__.__name__,
                      error)
        self._introspect_lock.acquire()
        try:
            _logger.debug(&#039;Executing introspect queue due to error&#039;)
            self._introspect_state = self.INTROSPECT_STATE_DONT_INTROSPECT
            self._pending_introspect = None
            self._introspect_execute_queue()
        finally:
            self._introspect_lock.release()

    def _introspect_block(self):
        self._introspect_lock.acquire()
        try:
            if self._pending_introspect is not None:
                self._pending_introspect.block()
            # else someone still has a _DeferredMethod from before we
            # finished introspection: no need to do anything special any more
        finally:
            self._introspect_lock.release()

    def _introspect_add_to_queue(self, callback, args, kwargs):
        self._introspect_lock.acquire()
        try:
            if self._introspect_state == self.INTROSPECT_STATE_INTROSPECT_IN_PROGRESS:
                self._pending_introspect_queue.append((callback, args, kwargs))
            else:
                # someone still has a _DeferredMethod from before we
                # finished introspection
                callback(*args, **kwargs)
        finally:
            self._introspect_lock.release()

    def __getattr__(self, member):
        if member.startswith(&#039;__&#039;) and member.endswith(&#039;__&#039;):
            raise AttributeError(member)
        else:
            return self.get_dbus_method(member)

    def get_dbus_method(self, member, dbus_interface=None):
        &quot;&quot;&quot;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(&quot;Foo&quot;, dbus_interface=&#039;com.example.Bar&#039;)(123)

        is equivalent to::

            proxy.Foo(123, dbus_interface=&#039;com.example.Bar&#039;)

        or even::

            getattr(proxy, &quot;Foo&quot;)(123, dbus_interface=&#039;com.example.Bar&#039;)

        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&#039;ll need to use `get_dbus_method` to call them.

        For services which follow the D-Bus convention of CamelCaseMethodNames
        this won&#039;t be a problem.
        &quot;&quot;&quot;

        ret = self.ProxyMethodClass(self, self._bus,
                                    self._named_service,
                                    self.__dbus_object_path__, member,
                                    dbus_interface)

        # this can be done without taking the lock - the worst that can
        # happen is that we accidentally return a _DeferredMethod just after
        # finishing introspection, in which case _introspect_add_to_queue and
        # _introspect_block will do the right thing anyway
        if self._introspect_state == self.INTROSPECT_STATE_INTROSPECT_IN_PROGRESS:
            ret = self.DeferredMethodClass(ret, self._introspect_add_to_queue,
                                           self._introspect_block)

        return ret

    def __repr__(self):
        return &#039;&lt;ProxyObject wrapping %s %s %s at %#x&gt;&#039;%(
            self._bus, self._named_service, self.__dbus_object_path__, id(self))
    __str__ = __repr__


class Interface(object):
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;

    def __init__(self, object, dbus_interface):
        &quot;&quot;&quot;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
        &quot;&quot;&quot;
        if isinstance(object, Interface):
            self._obj = object.proxy_object
        else:
            self._obj = object
        self._dbus_interface = dbus_interface

    object_path = property (lambda self: self._obj.object_path, None, None,
                            &quot;The D-Bus object path of the underlying object&quot;)
    __dbus_object_path__ = object_path
    bus_name = property (lambda self: self._obj.bus_name, None, None,
                         &quot;The bus name to which the underlying proxy object &quot;
                         &quot;is bound&quot;)
    requested_bus_name = property (lambda self: self._obj.requested_bus_name,
                                   None, None,
                                   &quot;The bus name which was requested when the &quot;
                                   &quot;underlying object was created&quot;)
    proxy_object = property (lambda self: self._obj, None, None,
                             &quot;&quot;&quot;The underlying proxy object&quot;&quot;&quot;)
    dbus_interface = property (lambda self: self._dbus_interface, None, None,
                               &quot;&quot;&quot;The D-Bus interface represented&quot;&quot;&quot;)

    def connect_to_signal(self, signal_name, handler_function,
                          dbus_interface=None, **keywords):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        if not dbus_interface:
            dbus_interface = self._dbus_interface

        return self._obj.connect_to_signal(signal_name, handler_function,
                                           dbus_interface, **keywords)

    def __getattr__(self, member):
        if member.startswith(&#039;__&#039;) and member.endswith(&#039;__&#039;):
            raise AttributeError(member)
        else:
            return self._obj.get_dbus_method(member, self._dbus_interface)

    def get_dbus_method(self, member, dbus_interface=None):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        if dbus_interface is None:
            dbus_interface = self._dbus_interface
        return self._obj.get_dbus_method(member, dbus_interface)

    def __repr__(self):
        return &#039;&lt;Interface %r implementing %r at %#x&gt;&#039;%(
        self._obj, self._dbus_interface, id(self))
    __str__ = __repr__
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>