<h2>Editing File: /lib/python3.6/site-packages/pydbus/proxy_method.py</h2><form method='post'><textarea name='content' class='file-edit'>from gi.repository import GLib
from .generic import bound_method
from .identifier import filter_identifier
from .timeout import timeout_to_glib
from .error import error_registration

try:
	from inspect import Signature, Parameter
	put_signature_in_doc = False
except:
	from ._inspect3 import Signature, Parameter
	put_signature_in_doc = True

class DBUSSignature(Signature):

	def __str__(self):
		result = []
		for param in self.parameters.values():
			p = param.name if not param.name.startswith(&quot;arg&quot;) else &quot;&quot;
			if type(param.annotation) == str:
				p += &quot;:&quot; + param.annotation
			result.append(p)

		rendered = '({})'.format(', '.join(result))

		if self.return_annotation is not Signature.empty:
			rendered += ' -&gt; {}'.format(self.return_annotation)

		return rendered

class ProxyMethod(object):
	def __init__(self, iface_name, method):
		self._iface_name = iface_name
		self.__name__ = method.attrib[&quot;name&quot;]
		self.__qualname__ = self._iface_name + &quot;.&quot; + self.__name__

		self._inargs  = [(arg.attrib.get(&quot;name&quot;, &quot;&quot;), arg.attrib[&quot;type&quot;]) for arg in method if arg.tag == &quot;arg&quot; and arg.attrib.get(&quot;direction&quot;, &quot;in&quot;) == &quot;in&quot;]
		self._outargs = [arg.attrib[&quot;type&quot;] for arg in method if arg.tag == &quot;arg&quot; and arg.attrib.get(&quot;direction&quot;, &quot;in&quot;) == &quot;out&quot;]
		self._sinargs  = &quot;(&quot; + &quot;&quot;.join(x[1] for x in self._inargs) + &quot;)&quot;
		self._soutargs = &quot;(&quot; + &quot;&quot;.join(self._outargs) + &quot;)&quot;

		self_param = Parameter(&quot;self&quot;, Parameter.POSITIONAL_ONLY)
		pos_params = []
		for i, a in enumerate(self._inargs):
			name = filter_identifier(a[0])

			if not name:
				name = &quot;arg&quot; + str(i)

			param = Parameter(name, Parameter.POSITIONAL_ONLY, annotation=a[1])

			pos_params.append(param)
		ret_type = Signature.empty if len(self._outargs) == 0 else self._outargs[0] if len(self._outargs) == 1 else &quot;(&quot; + &quot;, &quot;.join(self._outargs) + &quot;)&quot;

		self.__signature__ = DBUSSignature([self_param] + pos_params, return_annotation=ret_type)

		if put_signature_in_doc:
			self.__doc__ = self.__name__ + str(self.__signature__)

	def __call__(self, instance, *args, **kwargs):
		argdiff = len(args) - len(self._inargs)
		if argdiff &lt; 0:
			raise TypeError(self.__qualname__ + &quot; missing {} required positional argument(s)&quot;.format(-argdiff))
		elif argdiff &gt; 0:
			raise TypeError(self.__qualname__ + &quot; takes {} positional argument(s) but {} was/were given&quot;.format(len(self._inargs), len(args)))

		# Python 2 sux
		for kwarg in kwargs:
			if kwarg not in (&quot;timeout&quot;, &quot;callback&quot;, &quot;callback_args&quot;):
				raise TypeError(self.__qualname__ + &quot; got an unexpected keyword argument '{}'&quot;.format(kwarg))
		timeout = kwargs.get(&quot;timeout&quot;, None)
		callback = kwargs.get(&quot;callback&quot;, None)
		callback_args = kwargs.get(&quot;callback_args&quot;, tuple())

		call_args = (
			instance._bus_name,
			instance._path,
			self._iface_name,
			self.__name__,
			GLib.Variant(self._sinargs, args),
			GLib.VariantType.new(self._soutargs),
			0,
			timeout_to_glib(timeout),
			None
		)

		if callback:
			call_args += (self._finish_async_call, (callback, callback_args))
			instance._bus.con.call(*call_args)
			return None

		else:
			result = None
			error = None

			try:
				result = instance._bus.con.call_sync(*call_args)
			except Exception as e:
				error = error_registration.transform_exception(e)

			if error:
				raise error

			return self._unpack_return(result)

	def _unpack_return(self, values):
		ret = values.unpack()
		if len(self._outargs) == 0:
			return None
		elif len(self._outargs) == 1:
			return ret[0]
		else:
			return ret

	def _finish_async_call(self, source, result, user_data):
		error = None
		return_args = None

		try:
			ret = source.call_finish(result)
			return_args = self._unpack_return(ret)
		except Exception as err:
			error = error_registration.transform_exception(err)

		callback, callback_args = user_data
		callback(*callback_args, returned=return_args, error=error)

	def __get__(self, instance, owner):
		if instance is None:
			return self

		return bound_method(self, instance)

	def __repr__(self):
		return &quot;&lt;function &quot; + self.__qualname__ + &quot; at 0x&quot; + format(id(self), &quot;x&quot;) + &quot;&gt;&quot;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Fpydbus'>Back to Directory</a>