Mini Shell
3
��^�D � @ s� d dl Z d dlZd dl mZ d dlmZ d dlmZ d dlmZ d dl m
Z
m Z d dl m
Z
d dlmZ d d
d d gZd
ZG dd � d e�Zf fdd
�Zdd � Zdd � ZG dd� de�ZdS )� N)� Parameter)�get_type_hints)�
get_dbus_name)�Signal)�DBusSpecificationError�DBusSpecification)�
get_dbus_type)� XMLGenerator�
dbus_class�dbus_interface� dbus_signal�get_xmlZ __dbus_xml__c @ s6 e Zd ZdZdefdd�Zdd� Zdd� Zd d
� ZdS ) r a� DBus signal.
Can be used as:
.. code-block:: python
Signal = dbus_signal()
Or as a method decorator:
.. code-block:: python
@dbus_signal
def Signal(x: Int, y: Double):
pass
Signal is defined by the type hints of a decorated method.
This method is accessible as: signal.definition
If the signal is not defined by a method, it is expected to
have no arguments and signal.definition is equal to None.
Nc C s || _ || _d| _dS )z�Create a signal descriptor.
:param definition: a definition of the emit function
:param factory: a signal factory
N)�
definition�factory�name)�selfr r � r � /usr/lib/python3.6/interface.py�__init__F s zdbus_signal.__init__c C s. | j dk rdS djt| �jj� |j� �| _ dS )aV Set a name of the descriptor
The descriptor has been assigned to the specified name.
Generate a name of a private attribute that will be set
to a signal in the ``__get__`` method.
For example: ``__dbus_signal_my_name``
:param owner: the owning class
:param name: the descriptor name
Nz__{}_{})r �format�type�__name__�lower)r �ownerr r r r � __set_name__P s
zdbus_signal.__set_name__c C s< |dkr | S t || jd�}|dkr8| j� }t|| j|� |S )a� Get a value of the descriptor.
If the descriptor is accessed as a class attribute,
return the descriptor.
If the descriptor is accessed as an instance attribute,
return a signal created by the signal factory.
:param instance: an instance of the owning class
:param owner: an owning class
:return: a value of the attribute
N)�getattrr r �setattr)r �instancer �signalr r r �__get__d s
zdbus_signal.__get__c C s t d��dS )z Set a value of the descriptor.zCan't set DBus signal.N)�AttributeError)r r �valuer r r �__set__| s zdbus_signal.__set__) r �
__module__� __qualname__�__doc__r r r r r" r r r r r / s
c s � �fdd�}|S )a DBus interface.
A new DBus interface can be defined as:
.. code-block:: python
@dbus_interface
class Interface():
...
The interface will be generated from the given class cls
with a name interface_name and added to the DBus XML
specification of the class.
The XML specification is accessible as:
.. code-block:: python
Interface.__dbus_xml__
:param interface_name: a DBus name of the interface
:param namespace: a sequence of strings
c s* t �� f�� }tj| |�}t| t|� | S )N)r �DBusSpecificationGenerator�generate_specificationr �DBUS_XML_ATTRIBUTE)�clsr �xml)�interface_name� namespacer r � decorated� s z!dbus_interface.<locals>.decoratedr )r+ r, r- r )r+ r, r r � s c C s t j| �}t| t|� | S )a� DBus class.
A new DBus class can be defined as:
.. code-block:: python
@dbus_class
class Class(Interface):
...
DBus class can implement DBus interfaces, but it cannot
define a new interface.
The DBus XML specification will be generated from
implemented interfaces (inherited) and it will be
accessible as:
.. code-block:: python
Class.__dbus_xml__
)r& r' r r( )r) r* r r r r
� s
c C s& t | td�}|dkr"tdjt���|S )z�Return XML specification of an object.
:param obj: an object decorated with @dbus_interface or @dbus_class
:return: a string with XML specification
Nz)XML specification is not defined at '{}'.)r r( r r )�objZxml_specificationr r r r
� s c @ s� e Zd ZdZeZejd�Ze d dd��Z
e dd� �Z e dd � �Z e d
d � �Z
e d d
� �Ze dd� �Ze dd� �Ze dd� �Ze dd� �Ze dd� �Ze dd� �Ze dd� �Ze d d � �Ze d d � �ZdS )!r& z,Class for generating DBus XML specification.z[A-Z][A-Za-z0-9]*Nc C sN | j |�}|r6| j� }|j|� | j|||�}|||< | j||�}| jj|�S )aE Generates DBus XML specification for given class.
If class defines a new interface, it will be added to
the specification.
:param interface_cls: class object to decorate
:param str interface_name: name of the interface defined by class
:return str: DBus specification in XML
)�_collect_interfaces� _collect_standard_interfaces�update�_generate_interface�_generate_node�
xml_generatorZelement_to_xml)r) �
interface_clsr+ �
interfacesZall_interfaces� interface�noder r r r' � s
z1DBusSpecificationGenerator.generate_specificationc C s | j jtj�}| j j|�S )z�Collect standard interfaces.
Standard interfaces are implemented by default.
:return: a dictionary of standard interfaces
)r4 �xml_to_elementr ZSTANDARD_INTERFACES�get_interfaces_from_node)r) r8 r r r r0 � s z7DBusSpecificationGenerator._collect_standard_interfacesc C sV t � }xJttj|��D ]8}t|td�}|s,q| jj|�}| jj|�}|j |� qW |S )z�Collect interfaces implemented by the class.
Returns a dictionary that maps interface names
to interface elements.
:param interface_cls: a class object
:return: a dictionary of implemented interfaces
N)
�dict�reversed�inspectZgetmror r( r4 r9 r: r1 )r) r5 r6 �memberZ
member_xmlr8 Znode_interfacesr r r r/ s
z.DBusSpecificationGenerator._collect_interfacesc C s� | j j|�}x�tj|�D ]�\}}| j|�s,q| j||�r:q| j|�rR| j||�}n>| j|�rj| j ||�}n&| j
|�r�| j ||�}nt dj
|���| j j||� qW |S )ap Generate interface defined by given class.
:param interface_cls: a class object that defines the interface
:param interfaces: a dictionary of implemented interfaces
:param interface_name: a name of the new interface
:return: a new interface element
:raises DBusSpecificationError: if a class member cannot be exported
z+Unsupported definition of DBus member '{}'.)r4 Zcreate_interfacer= Z
getmembers�_is_exportable� _is_defined�
_is_signal�_generate_signal� _is_property�_generate_property�
_is_method�_generate_methodr r � add_child)r) r5 r6 r+ r7 � member_namer> �elementr r r r2 s"
z.DBusSpecificationGenerator._generate_interfacec C s t | jj|��S )z�Is the name of a class member exportable?
The name is exportable if it follows the DBus specification.
Only CamelCase names are allowed.
)�bool� NAME_PATTERN� fullmatch)r) rH r r r r? F s z)DBusSpecificationGenerator._is_exportablec C sD x>|j � D ]2}x,|D ]$}| jj|�s&q| jj||�s6qdS W q
W dS )z�Is the member name defined in given interfaces?
:param interfaces: a dictionary of interfaces
:param member_name: a name of the class member
:return: True if the name is defined, otherwise False
TF)�valuesr4 Z is_memberZhas_name)r) r6 rH r7 r> r r r r@ O s
z&DBusSpecificationGenerator._is_definedc C s
t |t�S )z"Is the class member a DBus signal?)�
isinstancer )r) r> r r r rA d s z%DBusSpecificationGenerator._is_signalc C sx | j j|�}|j}|s|S xX| j|�D ]J\}}}|tjkrHtdj|���tj}| j j|t |�|�}| j j
||� q&W |S )z�Generate signal defined by a class member.
:param member: a dbus_signal object.
:param member_name: a name of the signal
:return: a signal element
raises DBusSpecificationError: if signal has defined return type
z(Invalid return type of DBus signal '{}'.) r4 Z
create_signalr �_iterate_parametersr �
DIRECTION_OUTr r �create_parameterr rG ) r) r> rH rI �methodr � type_hint� direction� parameterr r r rB i s
z+DBusSpecificationGenerator._generate_signalc c s� t |�}tj|�}x`t|j�dd� D ]J}|j| j}|tjkrHtd��||kr^tdj |���||| t
j fV q&W |j |j
kr�dS |j dkr�dS t
j|j t
jfV dS )z�Iterate over method parameters.
For every parameter returns its name, a type hint and a direction.
:param member: a method object
:return: an iterator
raises DBusSpecificationError: if parameters are invalid
� Nz1Only positional or keyword arguments are allowed.z!Undefined type of parameter '{}'.)r r= � signature�listZ
parameters�kindr ZPOSITIONAL_OR_KEYWORDr r r Z DIRECTION_INZreturn_annotation�emptyZRETURN_PARAMETERrP )r) r> Z
type_hintsrW r rY r r r rO � s$
z.DBusSpecificationGenerator._iterate_parametersc C s
t |t�S )z$Is the class member a DBus property?)rN �property)r) r> r r r rC � s z'DBusSpecificationGenerator._is_propertyc C s� d}d}yD|j r*| j|j �\\}}}tj}|jrJ| j|j�\\}}}tj}W n" tk
rn tdj|���Y nX |jr�|j r�tj }|dkr�tdj|���| j
j |t |�|�S )z�Generate DBus property defined by class member.
:param member: a property object
:param member_name: a property name
:return: a property element
raises DBusSpecificationError: if the property is invalid
Nz%Undefined type of DBus property '{}'.z%DBus property '{}' is not accessible.)
�fsetrO r Z ACCESS_WRITE�fgetZ ACCESS_READ�
ValueErrorr r ZACCESS_READWRITEr4 Zcreate_propertyr )r) r> rH �accessrS �_r r r rD � s*
z-DBusSpecificationGenerator._generate_propertyc C s t j|�pt j|�S )a Is the class member a DBus method?
Ignore the difference between instance method and class method.
For example:
.. code-block:: python
class Foo(object):
def bar(cls, x):
pass
inspect.isfunction(Foo.bar) # True
inspect.isfunction(Foo().bar) # False
inspect.ismethod(Foo.bar) # False
inspect.ismethod(Foo().bar) # True
_is_method(Foo.bar) # True
_is_method(Foo().bar) # True
)r= ZismethodZ
isfunction)r) r> r r r rE � s z%DBusSpecificationGenerator._is_methodc C sL | j j|�}x:| j|�D ],\}}}| j j|t|�|�}| j j||� qW |S )z�Generate method defined by given class member.
:param member: a method object
:param member_name: a name of the method
:return: a method element
)r4 Z
create_methodrO rQ r rG )r) r> rH rR r rS rT rU r r r rF s z+DBusSpecificationGenerator._generate_methodc C sL | j j� }| j j|dj|j�� x&t|j� �D ]}| j j||| � q.W |S )z�Generate node element that specifies the given class.
:param interface_cls: a class object
:param interfaces: a dictionary of interfaces
:return: a node element
z Specifies {})r4 Z create_nodeZ add_commentr r �sorted�keysrG )r) r5 r6 r8 r+ r r r r3 s
z)DBusSpecificationGenerator._generate_node)N)r r# r$ r% r r4 �re�compilerK � classmethodr' r0 r/ r2 r? r@ rA rB rO rC rD rE rF r3 r r r r r& � s$
* $ 0 , r& )r= rc r Ztypingr Zdasbus.namespacer Z
dasbus.signalr Zdasbus.specificationr r Z
dasbus.typingr Z
dasbus.xmlr �__all__r( �objectr r r
r
r& r r r r �<module> s$ R