U
|
Z ±dg| ã @ sÐ U d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl Z d dlm
|
Z
|
ddl m Z m Z mZ ddlmZ dd lmZ dd
|
lmZ dd lmZmZmZ dd lmZ dd lm Z d dl Z e e d< e
|
rîe e e dddZ!ddlm"Z"m#Z# ndZ$zd dl m!Z! W nr e%k
|
rt ej&dkrld dl'Z'e'j(dddZ)e'j*e)j+_,e'j*e'j*e'j*ge)j+_-dZ.e e e dddZ!ndZ$Y nX G dd de e d Z/dddd e/d d d Z0d!d" Z1d#d$ Z2d%dddde j3d&d'd(Z4dS ))é N)Ú ExitStack)ÚOptional)Úpartial)Ú TYPE_CHECKINGé )Ú AsyncResourceÚ
|
SendStreamÚ ReceiveStream)ÚClosedResourceError)Ú StapledStream)ÚLock)Úwait_child_exitingÚcreate_pipe_to_child_stdinÚ create_pipe_from_child_output)Ú
|
deprecated)ÚNoPublicConstructorÚcan_try_pidfd_open)ÚfdÚflagsÚreturnc C s d S ©N© )r r r r úGd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_subprocess.pyÚ
|
pidfd_open s r )ÚClosableReceiveStreamÚClosableSendStreamT)r Úlinux)Ú use_errnoi² c C s2 t t| |¡}|dk r.t ¡ }t|t |¡|S ©Nr )Ú_cdll_for_pidfd_openÚsyscallÚ__NR_pidfd_openÚctypesÚ get_errnoÚOSErrorÚosÚstrerror)r r ÚresultÚerrr r r r ; s
|
Fc @ s e Zd ZdZdZdZdZdZdd Zdd Z e
|
dd Z e d
|
d d d ddd Z e d
|
d d ddd Zdd Zdd Zdd Zdd Zd d Zd d ZdS ) ÚProcessu¦ A child process. Like :class:`subprocess.Popen`, but async.
|
|
This class has no public constructor. The most common way to get a
|
`Process` object is to combine `Nursery.start` with `run_process`::
|
|
process_object = await nursery.start(run_process, ...)
|
|
This way, `run_process` supervises the process and makes sure that it is
|
cleaned up properly, while optionally checking the return value, feeding
|
it input, and so on.
|
|
If you need more control â for example, because you want to spawn a child
|
process that outlives your program â then another option is to use
|
`trio.lowlevel.open_process`::
|
|
process_object = await trio.lowlevel.open_process(...)
|
|
Attributes:
|
args (str or list): The ``command`` passed at construction time,
|
specifying the process to execute and its arguments.
|
pid (int): The process ID of the child process managed by this object.
|
stdin (trio.abc.SendStream or None): A stream connected to the child's
|
standard input stream: when you write bytes here, they become available
|
for the child to read. Only available if the :class:`Process`
|
was constructed using ``stdin=PIPE``; otherwise this will be None.
|
stdout (trio.abc.ReceiveStream or None): A stream connected to
|
the child's standard output stream: when the child writes to
|
standard output, the written bytes become available for you
|
to read here. Only available if the :class:`Process` was
|
constructed using ``stdout=PIPE``; otherwise this will be None.
|
stderr (trio.abc.ReceiveStream or None): A stream connected to
|
the child's standard error stream: when the child writes to
|
standard error, the written bytes become available for you
|
to read here. Only available if the :class:`Process` was
|
constructed using ``stderr=PIPE``; otherwise this will be None.
|
stdio (trio.StapledStream or None): A stream that sends data to
|
the child's standard input and receives from the child's standard
|
output. Only available if both :attr:`stdin` and :attr:`stdout` are
|
available; otherwise this will be None.
|
|
FNc C s || _ || _|| _|| _d | _| jd k rB| jd k rBt| j| j| _t | _d | _t rzt
|
| j j d}W n t k
|
rz Y n X t || _| j j| _| j j | _ d S r )Ú_procÚstdinÚstdoutÚstderrÚstdior r Ú
|
_wait_lockÚ_pidfdr r Úpidr$ ÚopenÚargs)ÚselfÚpopenr+ r, r- r r r r Ú__init__z s"
|
|
zProcess.__init__c C sJ | j }|d kr d | j¡}n |dk r2d | ¡}n
|
d |¡}d | j|¡S )Nzrunning with PID {}r zexited with signal {}zexited with status {}z<trio.Process {!r}: {}>)Ú
|
returncodeÚformatr1 r3 )r4 r7 Ústatusr r r Ú__repr__ s
|
zProcess.__repr__c C s | j ¡ }|dk r| ¡ |S )a The exit status of the process (an integer), or ``None`` if it's
|
still running.
|
|
By convention, a return code of zero indicates success. On
|
UNIX, negative values indicate termination due to a signal,
|
e.g., -11 if terminated by signal 11 (``SIGSEGV``). On
|
Windows, a process that exits due to a call to
|
:meth:`Process.terminate` will have an exit status of 1.
|
|
Unlike the standard library `subprocess.Popen.returncode`, you don't
|
have to call `poll` or `wait` to update this attribute; it's
|
automatically updated as needed, and will always give you the latest
|
information.
|
|
N)r* ÚpollÚ _close_pidfd)r4 r' r r r r7 £ s
|
zProcess.returncodez0.20.0z.using trio.Process as an async context manageriP z.run_process or nursery.start(run_process, ...))ÚthingÚissueÚinsteadc à s | S r r ©r4 r r r Ú
|
__aenter__¹ s zProcess.__aenter__)r> r? c à sº t jddT | jdk r(| j ¡ I dH | jdk rB| j ¡ I dH | jdk r\| j ¡ I dH W 5 Q R X z| ¡ I dH W 5 | jjdkr´| ¡ t jdd | ¡ I dH W 5 Q R X X dS )záClose any pipes we have to the process (both input and output)
|
and wait for it to exit.
|
|
If cancelled, kills the process and waits for it to finish
|
exiting before propagating the cancellation.
|
T©ZshieldN)
|
ÚtrioÚ CancelScoper+ Úacloser, r- r* r7 ÚkillÚwaitr@ r r r rE Â s
|
|
|
|
zProcess.aclosec C s0 | j d k r,tj | j ¡ ¡ | j ¡ d | _ d S r )r0 rC ÚlowlevelZnotify_closingÚfilenoÚcloser@ r r r r< Û s
|
|
zProcess._close_pidfdc
|
à s | j 4 I dH l | ¡ dkrv| jdk rVztj | j¡I dH W qd tk
|
rR Y qdX nt| I dH | j ¡ |
|
¡ W 5 Q I dH R X | jj dk st | jj S )z{Block until the process exits.
|
|
Returns:
|
The exit status of the process; see :attr:`returncode`.
|
N) r/ r; r0 rC rH Z wait_readabler
|
r r* rG r< r7 ÚAssertionErrorr@ r r r rG á s
|
|
z Process.waitc C s | j S )a Returns the exit status of the process (an integer), or ``None`` if
|
it's still running.
|
|
Note that on Trio (unlike the standard library `subprocess.Popen`),
|
``process.poll()`` and ``process.returncode`` always give the same
|
result. See `returncode` for more details. This method is only
|
included to make it easier to port code from `subprocess`.
|
|
)r7 r@ r r r r; ý s
|
z Process.pollc C s | j |¡ dS )a, Send signal ``sig`` to the process.
|
|
On UNIX, ``sig`` may be any signal defined in the
|
:mod:`signal` module, such as ``signal.SIGINT`` or
|
``signal.SIGTERM``. On Windows, it may be anything accepted by
|
the standard library :meth:`subprocess.Popen.send_signal`.
|
N)r* Ú send_signal)r4 Úsigr r r rL s zProcess.send_signalc C s | j ¡ dS )af Terminate the process, politely if possible.
|
|
On UNIX, this is equivalent to
|
``send_signal(signal.SIGTERM)``; by convention this requests
|
graceful termination, but a misbehaving or buggy process might
|
ignore it. On Windows, :meth:`terminate` forcibly terminates the
|
process in the same manner as :meth:`kill`.
|
N)r* Ú terminater@ r r r rN s zProcess.terminatec C s | j ¡ dS )a Immediately terminate the process.
|
|
On UNIX, this is equivalent to
|
``send_signal(signal.SIGKILL)``. On Windows, it calls
|
``TerminateProcess``. In both cases, the process cannot
|
prevent itself from being killed, but the termination will be
|
delivered asynchronously; use :meth:`wait` if you want to
|
ensure the process is actually dead before proceeding.
|
N)r* rF r@ r r r rF s
|
z Process.kill)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Úuniversal_newlinesÚencodingÚerrorsZ_wait_for_exit_datar6 r: Úpropertyr7 r rA rE r< rG r; rL rN rF r r r r r) F s8 *
|
ü
|
ÿ
|
|
r) )Ú metaclass©r+ r, r- )r c
|
Ë sz dD ] }| |¡rtd |¡qtjdkrdt| trH| d¡sHtdt| tsd| d¡rdtdd}d}d}t î} t Ü}
|
|tj kr®t
|
\}}| tj |¡ |
|
|j ¡ |tj krÜt \}}| tj |¡ |
|
|j ¡ |tjkrô|dk rò|}n0|tj kr$t \}}| tj |¡ |
|
|j ¡ tj ttj| f|||d|¡I dH } |
|
¡ W 5 Q R X W 5 Q R X t | |||¡S ) aF
|
Execute a child program in a new process.
|
|
After construction, you can interact with the child process by writing data to its
|
`~trio.Process.stdin` stream (a `~trio.abc.SendStream`), reading data from its
|
`~trio.Process.stdout` and/or `~trio.Process.stderr` streams (both
|
`~trio.abc.ReceiveStream`\s), sending it signals using `~trio.Process.terminate`,
|
`~trio.Process.kill`, or `~trio.Process.send_signal`, and waiting for it to exit
|
using `~trio.Process.wait`. See `trio.Process` for details.
|
|
Each standard stream is only available if you specify that a pipe should be created
|
for it. For example, if you pass ``stdin=subprocess.PIPE``, you can write to the
|
`~trio.Process.stdin` stream, else `~trio.Process.stdin` will be ``None``.
|
|
Unlike `trio.run_process`, this function doesn't do any kind of automatic
|
management of the child process. It's up to you to implement whatever semantics you
|
want.
|
|
Args:
|
command (list or str): The command to run. Typically this is a
|
sequence of strings such as ``['ls', '-l', 'directory with spaces']``,
|
where the first element names the executable to invoke and the other
|
elements specify its arguments. With ``shell=True`` in the
|
``**options``, or on Windows, ``command`` may alternatively
|
be a string, which will be parsed following platform-dependent
|
:ref:`quoting rules <subprocess-quoting>`.
|
stdin: Specifies what the child process's standard input
|
stream should connect to: output written by the parent
|
(``subprocess.PIPE``), nothing (``subprocess.DEVNULL``),
|
or an open file (pass a file descriptor or something whose
|
``fileno`` method returns one). If ``stdin`` is unspecified,
|
the child process will have the same standard input stream
|
as its parent.
|
stdout: Like ``stdin``, but for the child process's standard output
|
stream.
|
stderr: Like ``stdin``, but for the child process's standard error
|
stream. An additional value ``subprocess.STDOUT`` is supported,
|
which causes the child's standard output and standard error
|
messages to be intermixed on a single standard output stream,
|
attached to whatever the ``stdout`` option says to attach it to.
|
**options: Other :ref:`general subprocess options <subprocess-options>`
|
are also accepted.
|
|
Returns:
|
A new `trio.Process` object.
|
|
Raises:
|
OSError: if the process spawning fails, for example because the
|
specified command could not be found.
|
|
)rS ÚtextrT rU Úbufsizezgtrio.Process only supports communicating over unbuffered byte streams; the '{}' option is not supportedÚposixÚshellzHcommand must be a sequence (not a string) if shell=False on UNIX systemszGcommand must be a string (not a sequence) if shell=True on UNIX systemsNrX )ÚgetÚ TypeErrorr8 r% ÚnameÚ
|
isinstanceÚstrr Ú
|
subprocessÚPIPEr ÚcallbackrJ r ÚSTDOUTrC Z to_threadZrun_syncr ÚPopenÚpop_allr) Ú_create) Úcommandr+ r, r- ÚoptionsÚkeyZ
|
trio_stdinZ trio_stdoutZ trio_stderrZalways_cleanupZcleanup_on_failr5 r r r Ú open_process+ sb 5
|
ÿÿ
|
ÿÿ
|
|
|
|
|
|
þûúÿ
|
rl c
|
à sN z | ¡ W n< tk
|
rH } z t td| d|¡ W 5 d }~X Y nX d S )NzTerminateProcess on z failed with: )rN r$ ÚwarningsÚwarnÚRuntimeWarning©ÚpÚexcr r r Ú_windows_deliver_cancel£ s rs c
|
à s| z:| ¡ t d¡I d H t td| d¡ | ¡ W n< tk
|
rv } z t td| d|¡ W 5 d }~X Y nX d S )Né zprocess z` ignored SIGTERM for 5 seconds. (Maybe you should pass a custom deliver_cancel?) Trying SIGKILL.ztried to kill process z, but failed with: )rN rC Úsleeprm rn ro rF r$ rp r r r Ú_posix_deliver_cancelª s
|
ÿÿ ÿrv ó )r+ Úcapture_stdoutÚcapture_stderrÚcheckÚdeliver_cancelÚ task_statusc s t |trtd|tjkr^|tjkr.td| d¡tjkrFtd| d¡tjkr^tdt |t t
|
t fr~|tj|d< n d||d< |r¨d|krtd tj|d< |rÆd|kr¼td
|
tj|d< dkrðt j d krÞt nt j d ksìtt g }g } fd d}
|
dd } t ¡ 4 I dH } t| f|I dH z~dk rX| |
|
j¡ d_d_|rz| | j|¡ d_d_|r| | j| ¡ d_| ¡ ¡ I dH W nl tk
|
r tjddD tjdd fdd} | | ¡ ¡ I dH ¡ W 5 Q R X Y nX W 5 Q I dH R X |r>d |¡nd}|rRd | ¡nd}j r||r|tj j j ||dnt !j j ||¡S dS )uÿ% Run ``command`` in a subprocess and wait for it to complete.
|
|
This function can be called in two different ways.
|
|
One option is a direct call, like::
|
|
completed_process_info = await trio.run_process(...)
|
|
In this case, it returns a :class:`subprocess.CompletedProcess` instance
|
describing the results. Use this if you want to treat a process like a
|
function call.
|
|
The other option is to run it as a task using `Nursery.start` â the enhanced version
|
of `~Nursery.start_soon` that lets a task pass back a value during startup::
|
|
process = await nursery.start(trio.run_process, ...)
|
|
In this case, `~Nursery.start` returns a `Process` object that you can use
|
to interact with the process while it's running. Use this if you want to
|
treat a process like a background task.
|
|
Either way, `run_process` makes sure that the process has exited before
|
returning, handles cancellation, optionally checks for errors, and
|
provides some convenient shorthands for dealing with the child's
|
input/output.
|
|
**Input:** `run_process` supports all the same ``stdin=`` arguments as
|
`subprocess.Popen`. In addition, if you simply want to pass in some fixed
|
data, you can pass a plain `bytes` object, and `run_process` will take
|
care of setting up a pipe, feeding in the data you gave, and then sending
|
end-of-file. The default is ``b""``, which means that the child will receive
|
an empty stdin. If you want the child to instead read from the parent's
|
stdin, use ``stdin=None``.
|
|
**Output:** By default, any output produced by the subprocess is
|
passed through to the standard output and error streams of the
|
parent Trio process.
|
|
When calling `run_process` directly, you can capture the subprocess's output by
|
passing ``capture_stdout=True`` to capture the subprocess's standard output, and/or
|
``capture_stderr=True`` to capture its standard error. Captured data is collected up
|
by Trio into an in-memory buffer, and then provided as the
|
:attr:`~subprocess.CompletedProcess.stdout` and/or
|
:attr:`~subprocess.CompletedProcess.stderr` attributes of the returned
|
:class:`~subprocess.CompletedProcess` object. The value for any stream that was not
|
captured will be ``None``.
|
|
If you want to capture both stdout and stderr while keeping them
|
separate, pass ``capture_stdout=True, capture_stderr=True``.
|
|
If you want to capture both stdout and stderr but mixed together
|
in the order they were printed, use: ``capture_stdout=True, stderr=subprocess.STDOUT``.
|
This directs the child's stderr into its stdout, so the combined
|
output will be available in the `~subprocess.CompletedProcess.stdout`
|
attribute.
|
|
If you're using ``await nursery.start(trio.run_process, ...)`` and want to capture
|
the subprocess's output for further processing, then use ``stdout=subprocess.PIPE``
|
and then make sure to read the data out of the `Process.stdout` stream. If you want
|
to capture stderr separately, use ``stderr=subprocess.PIPE``. If you want to capture
|
both, but mixed together in the correct order, use ``stdout=subprocess.PIPE,
|
stderr=subprocess.STDOUT``.
|
|
**Error checking:** If the subprocess exits with a nonzero status
|
code, indicating failure, :func:`run_process` raises a
|
:exc:`subprocess.CalledProcessError` exception rather than
|
returning normally. The captured outputs are still available as
|
the :attr:`~subprocess.CalledProcessError.stdout` and
|
:attr:`~subprocess.CalledProcessError.stderr` attributes of that
|
exception. To disable this behavior, so that :func:`run_process`
|
returns normally even if the subprocess exits abnormally, pass ``check=False``.
|
|
Note that this can make the ``capture_stdout`` and ``capture_stderr``
|
arguments useful even when starting `run_process` as a task: if you only
|
care about the output if the process fails, then you can enable capturing
|
and then read the output off of the `~subprocess.CalledProcessError`.
|
|
**Cancellation:** If cancelled, `run_process` sends a termination
|
request to the subprocess, then waits for it to fully exit. The
|
``deliver_cancel`` argument lets you control how the process is terminated.
|
|
.. note:: `run_process` is intentionally similar to the standard library
|
`subprocess.run`, but some of the defaults are different. Specifically, we
|
default to:
|
|
- ``check=True``, because `"errors should never pass silently / unless
|
explicitly silenced" <https://www.python.org/dev/peps/pep-0020/>`__.
|
|
- ``stdin=b""``, because it produces less-confusing results if a subprocess
|
unexpectedly tries to read from stdin.
|
|
To get the `subprocess.run` semantics, use ``check=False, stdin=None``.
|
|
Args:
|
command (list or str): The command to run. Typically this is a
|
sequence of strings such as ``['ls', '-l', 'directory with spaces']``,
|
where the first element names the executable to invoke and the other
|
elements specify its arguments. With ``shell=True`` in the
|
``**options``, or on Windows, ``command`` may alternatively
|
be a string, which will be parsed following platform-dependent
|
:ref:`quoting rules <subprocess-quoting>`.
|
|
stdin (:obj:`bytes`, subprocess.PIPE, file descriptor, or None): The
|
bytes to provide to the subprocess on its standard input stream, or
|
``None`` if the subprocess's standard input should come from the
|
same place as the parent Trio process's standard input. As is the
|
case with the :mod:`subprocess` module, you can also pass a file
|
descriptor or an object with a ``fileno()`` method, in which case
|
the subprocess's standard input will come from that file.
|
|
When starting `run_process` as a background task, you can also use
|
``stdin=subprocess.PIPE``, in which case `Process.stdin` will be a
|
`~trio.abc.SendStream` that you can use to send data to the child.
|
|
capture_stdout (bool): If true, capture the bytes that the subprocess
|
writes to its standard output stream and return them in the
|
`~subprocess.CompletedProcess.stdout` attribute of the returned
|
`subprocess.CompletedProcess` or `subprocess.CalledProcessError`.
|
|
capture_stderr (bool): If true, capture the bytes that the subprocess
|
writes to its standard error stream and return them in the
|
`~subprocess.CompletedProcess.stderr` attribute of the returned
|
`~subprocess.CompletedProcess` or `subprocess.CalledProcessError`.
|
|
check (bool): If false, don't validate that the subprocess exits
|
successfully. You should be sure to check the
|
``returncode`` attribute of the returned object if you pass
|
``check=False``, so that errors don't pass silently.
|
|
deliver_cancel (async function or None): If `run_process` is cancelled,
|
then it needs to kill the child process. There are multiple ways to
|
do this, so we let you customize it.
|
|
If you pass None (the default), then the behavior depends on the
|
platform:
|
|
- On Windows, Trio calls ``TerminateProcess``, which should kill the
|
process immediately.
|
|
- On Unix-likes, the default behavior is to send a ``SIGTERM``, wait
|
5 seconds, and send a ``SIGKILL``.
|
|
Alternatively, you can customize this behavior by passing in an
|
arbitrary async function, which will be called with the `Process`
|
object as an argument. For example, the default Unix behavior could
|
be implemented like this::
|
|
async def my_deliver_cancel(process):
|
process.send_signal(signal.SIGTERM)
|
await trio.sleep(5)
|
process.send_signal(signal.SIGKILL)
|
|
When the process actually exits, the ``deliver_cancel`` function
|
will automatically be cancelled â so if the process exits after
|
``SIGTERM``, then we'll never reach the ``SIGKILL``.
|
|
In any case, `run_process` will always wait for the child process to
|
exit before raising `Cancelled`.
|
|
**options: :func:`run_process` also accepts any :ref:`general subprocess
|
options <subprocess-options>` and passes them on to the
|
:class:`~trio.Process` constructor. This includes the
|
``stdout`` and ``stderr`` options, which provide additional
|
redirection possibilities such as ``stderr=subprocess.STDOUT``,
|
``stdout=subprocess.DEVNULL``, or file descriptors.
|
|
Returns:
|
|
When called normally â a `subprocess.CompletedProcess` instance
|
describing the return code and outputs.
|
|
When called via `Nursery.start` â a `trio.Process` instance.
|
|
Raises:
|
UnicodeError: if ``stdin`` is specified as a Unicode string, rather
|
than bytes
|
ValueError: if multiple redirections are specified for the same
|
stream, e.g., both ``capture_stdout=True`` and
|
``stdout=subprocess.DEVNULL``
|
subprocess.CalledProcessError: if ``check=False`` is not passed
|
and the process exits with a nonzero exit status
|
OSError: if an error is encountered starting or communicating with
|
the process
|
|
.. note:: The child process runs in the same process group as the parent
|
Trio process, so a Ctrl+C will be delivered simultaneously to both
|
parent and child. If you don't want this behavior, consult your
|
platform's documentation for starting child processes in a different
|
process group.
|
|
z$process stdin must be bytes, not strz¤stdout=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the pipe; use nursery.start or pass the data you want to write directlyr, zestdout=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the piper- zestderr=subprocess.PIPE is only valid with nursery.start, since that's the only way to access the piper+ Nz,can't specify both stdout and capture_stdoutz,can't specify both stderr and capture_stderrÚntr[ c
|
sN | 4 I d H 2 z| ¡I d H W n tjk
|
r8 Y nX W 5 Q I d H R X d S r )Zsend_allrC ZBrokenResourceError)Ústream)Úinputr r Ú
|
feed_input· s
|
z run_process.<locals>.feed_inputc
|
Ó s@ | 4 I d H $ | 2 z3 d H W }| |¡ q6 W 5 Q I d H R X d S r )Úappend)r~ ÚchunksÚchunkr r r Ú read_output¾ s z run_process.<locals>.read_outputTrB c s" I d H W 5 Q R X d S r r r )r{ Ú killer_cscopeÚprocr r Úkiller× s zrun_process.<locals>.killerrw )Úoutputr- )"r` ra Ú UnicodeErrorrC ÚTASK_STATUS_IGNOREDrb rc Ú
|
ValueErrorr] ÚbytesÚ bytearrayÚ
|
memoryviewr% r_ rs rK rv Z open_nurseryrl Z
|
start_soonr+ r. r, r- ÚstartedrG Ú BaseExceptionrD ÚcancelÚjoinr7 ÚCalledProcessErrorr3 ÚCompletedProcess)ri r+ rx ry rz r{ r| rj Z stdout_chunksZ stderr_chunksr r Znurseryr r, r- r )r{ r r
r r Ú run_process¼ s L
|
|
|
ÿÿÿ
|
|
|
|
|
|
" ÿr )5r% rb ÚsysÚ
|
contextlibr Útypingr Ú functoolsr rm r Ú_abcr r r Z_corer
|
Z_highlevel_genericr Z_syncr Z_subprocess_platformr r r Z
|
_deprecater Z_utilr rC ÚboolÚ__annotations__Úintr r r r Ú ImportErrorÚplatformr" ÚCDLLr Úc_longr ÚrestypeÚargtypesr! r) rl rs rv r r r r r r Ú<module> sh
|
ý
|
g ÿþ xø
|
