/usr/lib/python3/dist-packages/jeepney/io/__pycache__
Edit: /usr/lib/python3/dist-packages/jeepney/io/__pycache__/asyncio.cpython-310.pyc (8938B)
o
a @ s d dl Z d dlZd dlmZ d dlmZ d dlmZmZ d dl m
Z
d dl m Z m
Z
mZ d dlmZmZ d dlmZ d d
lmZmZmZmZmZ G d d d ZdddZG dd dZ G dd dZ G dd deZ dS ) N)count)Optional)
AuthenticatorBEGIN)get_bus)Message MessageTypeParser) ProxyBase
unwrap_msg) message_bus )MessageFilters FilterHandle ReplyMatcher RouterClosedcheck_replyablec @ s` e Zd ZdZdejdejfddZdddefd d
Z d efd d
Z
dd Z dd Z dd Z
dS )DBusConnectionaP A plain D-Bus connection with no matching of replies.
This doesn't run any separate tasks: sending and receiving are done in
the task that calls those methods. It's suitable for implementing servers:
several worker tasks can receive requests and send replies.
For a typical client pattern, see :class:`DBusRouter`.
readerwriterc C s4 || _ || _t | _tdd| _d | _t | _ d S )Nr
)start)
r r r parserr outgoing_serial unique_nameasyncioLock send_lock)selfr r r 4/usr/lib/python3/dist-packages/jeepney/io/asyncio.py__init__ s zDBusConnection.__init__Nserialmessagec sv | j 4 I dH & |du rt| j}| j|| | j I dH W d I dH dS 1 I dH s4w Y dS )z.Serialise and send a :class:`~.Message` objectN)r nextr r write serialisedrainr r# r" r r r send s
.zDBusConnection.sendreturnc sB | j }|dur
|S | jdI dH }|st| j | q)z5Return the next available message from the connectionTNi )r get_next_messager readEOFErroradd_data)r msgbr r r receive( s
zDBusConnection.receivec s | j | j I dH dS )zClose the D-Bus connectionN)r close wait_closedr r r r r2 4 s
zDBusConnection.closec | S Nr r4 r r r
__aenter__9 zDBusConnection.__aenter__c s | I d H d S r6 )r2 r exc_typeexc_valexc_tbr r r __aexit__< s zDBusConnection.__aexit__)__name__
__module__ __qualname____doc__r StreamReader StreamWriterr r r) r1 r2 r7 r= r r r r r s r SESSIONc
s t | }t|I dH \}}t }|D ]!}|| | I dH |dI dH }|s0td|| q|t | I dH t
||}t |4 I dH }t t
t| dI dH } | d |_W d I dH |S 1 I dH stw Y |S )zHOpen a plain D-Bus connection
:return: :class:`DBusConnection`
Ni z#Socket closed before authentication
r )r r open_unix_connectionr r% r' r, r- feedr r
DBusRouterwait_forProxyr Hellor )
busbus_addrr r authrreq_datar0 connrouter
reply_bodyr r r open_dbus_connection@ s*
rS c @ s e Zd ZdZdZdZdZdefddZe dd Z
ddd d
Z d e fd d
Z
ddddeej fddZdd Zdd Zde fddZdd ZdS ) rH zA 'client' D-Bus connection which can wait for a specific reply.
This runs a background receiver task, and makes it possible to send a
request and wait for the relevant reply.
NrP c C s* || _ t | _t | _t| | _d S r6 ) _connr _repliesr _filtersr create_task _receiver _rcv_task)r rP r r r r j s zDBusRouter.__init__c C s | j jS r6 )rT r r4 r r r r p s zDBusRouter.unique_namer! c s | j j||dI dH dS )z&Send a message, don't wait for a replyr! N)rT r) r( r r r r) t s zDBusRouter.sendr* c s| t | | j rtdt| jj}| j|t
}| j ||dI dH |I dH W d S 1 s7w Y dS )zSend a method call message and wait for the reply
Returns the reply message (method return or error message type).
zThis DBusRouter has stoppedr! N) r rY doner r$ rT r rU catchr Futurer) )r r# r" reply_futr r r send_and_get_replyx s
$z DBusRouter.send_and_get_replyr
)queuebufsizer_ c C s t | j||p
t|S )ar Create a filter for incoming messages
Usage::
with router.filter(rule) as queue:
matching_msg = await queue.get()
:param MatchRule rule: Catch messages matching this rule
:param asyncio.Queue queue: Send matching messages here
:param int bufsize: If no queue is passed in, create one with this size
)r rV r Queue)r ruler_ r` r r r filter s zDBusRouter.filterc r5 r6 r r4 r r r r7 r8 zDBusRouter.__aenter__c sb | j r
| j dS | j ttj | j I d H W d dS 1 s*w Y dS )NF)rY rZ resultcancel
contextlibsuppressr CancelledErrorr9 r r r r= s
zDBusRouter.__aexit__r/ c C sN | j |rdS t| j|D ]}z|j| W q tjy$ Y qw dS )zHandle one received messageN) rU dispatchlistrV matchesr_
put_nowaitr QueueFull)r r/ rc r r r _dispatch s zDBusRouter._dispatchc s. z | j I dH }| | q| j w )z'Receiver loop - runs in a separate taskTN)rT r1 rn rU drop_all)r r/ r r r rX s
zDBusRouter._receiver)r> r? r@ rA _nursery_mgr_send_cancel_scope_rcv_cancel_scoper r propertyr r) r r^ r r ra rc r7 r= rn rX r r r r rH ` s
rH c @ s2 e Zd ZdZdZdZd
ddZdd Zdd ZdS ) open_dbus_routerzOpen a D-Bus 'router' to send and receive messages
Use as an async context manager::
async with open_dbus_router() as router:
...
NrD c C s
|| _ d S r6 )rL )r rL r r r r s
zopen_dbus_router.__init__c s0 t | jI d H | _t| j| _| j I d H S r6 )rS rL rP rH req_ctxr7 r4 r r r r7 s zopen_dbus_router.__aenter__c s, | j |||I d H | j I d H d S r6 )ru r= rP r2 r9 r r r r= s zopen_dbus_router.__aexit__rD ) r> r? r@ rA rP ru r r7 r= r r r r rt s
rt c s0 e Zd ZdZ fddZdd Zdd Z ZS )rJ a An asyncio proxy for calling D-Bus methods
You can call methods on the proxy object, such as ``await bus_proxy.Hello()``
to make a method call over D-Bus and wait for a reply. It will either
return a tuple of returned data, or raise :exc:`.DBusErrorResponse`.
The methods available are defined by the message generator you wrap.
:param msggen: A message generator object.
:param ~asyncio.DBusRouter router: Router to send and receive messages.
c s t | || _d S r6 )superr _router)r msggenrQ __class__r r r s
zProxy.__init__c C s d | j| jS )Nz
Proxy({}, {}))format_msggenrx r4 r r r __repr__ s zProxy.__repr__c s fdd}|S )Nc s< | i |}|j jtju sJ j|I d H }t|S r6 )header message_typer method_callrx r^ r )argskwargsr/ replymake_msgr r r inner s
z!Proxy._method_call.
.innerr )r r r r r r _method_call s zProxy._method_call)r> r? r@ rA r r~ r
__classcell__r r rz r rJ s
rJ rv ) r rf itertoolsr typingr jeepney.authr r jeepney.busr jeepneyr r r jeepney.wrappersr
r jeepney.bus_messagesr commonr r r r r r rS rH rt rJ r r r r s
0 X