U
|
X ±dMA ã @ s d dl Z d dlmZ d dlmZmZ d dlmZmZ d dl Z d dl
|
Z
|
d dl Z d dl m Z d dl mZ e e¡Ze jdkr d dlZd dlZd dlZG dd d ejZd
|
Ze e¡Zej j j Z e ej j ¡e ej j ¡eej j!ge _"ej j#e _$ej j j%Z%ej j ge%_"ej j#e%_$ee& 'd ¡Z(d d Z)dd Z*e jdkrHdd Z+dd Z,ndd Z+dd Z,e-e-dddZ.dd Z/G dd d Z0d d Z1d d Z2dS )!é N)ÚPath)ÚloadsÚdumps)Ú b64encodeÚ b64decode)Úcompat)ÚlogÚntc @ s. e Zd ZdejjfdejjfdejjfgZdS )ÚSECURITY_ATTRIBUTESÚnLengthÚlpSecurityDescriptorÚbInheritHandleN) Ú__name__Ú
|
__module__Ú __qualname__ÚctypesÚwintypesÚDWORDÚLPVOIDÚBOOLÚ_fields_© r r úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\PyInstaller/isolated/_parent.pyr
|
s
|
|
|
ýr
|
é z _child.pyc C s
|
t | |S )aÄ
|
Create a one-way pipe for sending data to child processes.
|
|
Args:
|
read_handle_inheritable:
|
A boolean flag indicating whether the handle corresponding to the read end-point of the pipe should be
|
marked as inheritable by subprocesses.
|
write_handle_inheritable:
|
A boolean flag indicating whether the handle corresponding to the write end-point of the pipe should be
|
marked as inheritable by subprocesses.
|
|
Returns:
|
A read/write pair of file descriptors (which are just integers) on posix or system file handles on Windows.
|
|
The pipe may be used either by this process or subprocesses of this process but not globally.
|
)Ú_create_pipe_impl)Úread_handle_inheritableÚwrite_handle_inheritabler r r Ú create_pipe< s r c C s t | S )zT
|
Close the file descriptor (posix) or handle (Windows) belonging to a pipe.
|
)Ú_close_pipe_endpoint_impl)Ú pipe_handler r r Úclose_pipe_endpointP s r c C s t j ¡ }t j ¡ }t }t |¡|_d|_d |_tt |¡t |¡t |¡d}|s^t
|
¡ t |j | ¡ t |j |¡ |j |j fS )NTr )r r ÚHANDLEr
|
Úsizeofr r r Ú
|
CreatePipeÚbyrefÚWinErrorÚosÚset_handle_inheritableÚvalue)r r Z read_handleZ write_handleZsecurity_attributesÚ succeededr r r r Y s"
|
|
ür c C s t | }|st ¡ d S ©N)Ú CloseHandler r% )r r) r r r r w s r c C s, t ¡ \}}t || ¡ t ||¡ ||fS r* )r& ÚpipeÚset_inheritable)Zread_fd_inheritableZwrite_fd_inheritableZread_fdZwrite_fdr r r r } s c C s t | ¡ d S r* )r& Úclose)Zpipe_fdr r r r s )Úread_from_parentÚwrite_to_parentc C sf t jdkrt dd}n t dtjd| |gidd}t ttt| t|g|¡\}}tj |f|S )zu
|
Spawn a Python subprocess sending it the two file descriptors it needs to talk back to this parent process.
|
r F)ÚenvÚ close_fdsTÚ handle_list)ÚlpAttributeList)r1 r2 Ú startupinfo)
|
r& ÚnameÚ_subprocess_envÚ
|
subprocessÚ STARTUPINFOr Z __wrap_pythonÚstrÚCHILD_PYÚPopen)r/ r0 Ú extra_kwargsÚcmdÚoptionsr r r Úchild s
|
þý"r@ c C sL ddl m} | d }dtjkr.|tjd g }tj ¡ }tj |¡|d< |S )zM
|
Define the environment variables to be readable in a child process.
|
r )ÚCONFZpathexÚ
|
PYTHONPATH)ZPyInstaller.configrA r& ÚenvironÚcopyÚpathsepÚjoin)rA Z python_pathr1 r r r r7 § s
|
|
r7 c @ s: e Zd ZdZd ddZdd Zdd Zd d
|
Zd d ZdS )ÚPythona&
|
Start and connect to a separate Python subprocess.
|
|
This is the lowest level of public API provided by this module. The advantage of using this class directly is
|
that it allows multiple functions to be evaluated in a single subprocess, making it faster than multiple calls to
|
:func:`call`.
|
|
The ``strict_mode`` argument controls behavior when the child process fails to shut down; if strict mode is enabled,
|
an error is raised, otherwise only warning is logged. If the value of ``strict_mode`` is ``None``, the value of
|
``PyInstaller.compat.strict_collect_mode`` is used (which in turn is controlled by the
|
``PYINSTALLER_STRICT_COLLECT_MODE`` environment variable.
|
|
Examples:
|
To call some predefined functions ``x = foo()``, ``y = bar("numpy")`` and ``z = bazz(some_flag=True)`` all using
|
the same isolated subprocess use::
|
|
with isolated.Python() as child:
|
x = child.call(foo)
|
y = child.call(bar, "numpy")
|
z = child.call(bazz, some_flag=True)
|
|
Nc C s d | _ |d k r|ntj| _d S r* )Ú_childr Zstrict_collect_modeÚ _strict_mode)ÚselfZ strict_moder r r Ú__init__Ë s zPython.__init__c C s t dd\}}t dd\}}t||| _t| t| ~~tjdkrtt t |d¡d¡| _ t t |d¡d¡| _
|
n t |d¡| _ t |d¡| _
|
| t j ¡ | S )NFTr r ÚwbÚrb)r r@ rH r r& r6 ÚfdopenÚmsvcrtÚopen_osfhandleÚ _write_handleÚ _read_handleÚ_sendÚsysÚpath)rJ Zread_from_childr0 r/ Zwrite_to_childr r r Ú __enter__Ò s
|
zPython.__enter__c C sÈ | j d¡ | j ¡ d}z| jjdd W nb tjk
|
r t d¡ d}| j ¡ z| jjdd W n tjk
|
r t d¡ Y nX Y nX | j
|
¡ | j
|
¡ | ` | ` d | _|rÄ| j rÄt dd S ) Nó
|
Fé )Útimeoutz6Timed out while waiting for the child process to exit!Té z;Timed out while waiting for the child process to be killed!)rQ ÚwriteÚflushrH Úwaitr8 ÚTimeoutExpiredÚloggerÚwarningÚkillr. rR rI Ú RuntimeError)rJ Úexc_typeÚexc_valÚexc_tbZshutdown_errorr r r Ú__exit__ô s&
|
|
|
|
|
|
zPython.__exit__c O sb | j dkrtd| |j|j|j||¡ tt| j ¡ \}}|rH|S td|j
|
d| dS )z¡
|
Call a function in the child Python. Retrieve its return value. Usage of this method is identical to that
|
of the :func:`call` function.
|
Nz:An isolated.Python object must be used in a 'with' clause.zChild process call to z() failed with:
|
) rH rb rS Ú__code__Ú __defaults__Ú__kwdefaults__r r rR Úreadliner )rJ ÚfunctionÚargsÚkwargsÚokÚoutputr r r Úcall s
|
z Python.callc G s8 |D ]$}| j tt|¡ | j d¡ q| j ¡ d S )NrW )rQ r[ r r r\ )rJ ZobjectsÚobjectr r r rS 0 s z Python._send)N) r r r Ú__doc__rK rV rf rp rS r r r r rG ´ s
|
"%rG c
|
O s0 t }|j| f||W 5 Q R £ S Q R X dS )a¾
|
Call a function with arguments in a separate child Python. Retrieve its return value.
|
|
Args:
|
function:
|
The function to send and invoke.
|
*args:
|
**kwargs:
|
Positional and keyword arguments to send to the function. These must be simple builtin types - not custom
|
classes.
|
Returns:
|
The return value of the function. Again, these must be basic types serialisable by :func:`marshal.dumps`.
|
Raises:
|
RuntimeError:
|
Any exception which happens inside an isolated process is caught and reraised in the parent process.
|
|
To use, define a function which returns the information you're looking for. Any imports it requires must happen in
|
the body of the function. For example, to safely check the output of ``matplotlib.get_data_path()`` use::
|
|
# Define a function to be ran in isolation.
|
def get_matplotlib_data_path():
|
import matplotlib
|
return matplotlib.get_data_path()
|
|
# Call it with isolated.call().
|
get_matplotlib_data_path = isolated.call(matplotlib_data_path)
|
|
For single use functions taking no arguments like the above you can abuse the decorator syntax slightly to define
|
and execute a function in one go. ::
|
|
>>> @isolated.call
|
... def matplotlib_data_dir():
|
... import matplotlib
|
... return matplotlib.get_data_path()
|
>>> matplotlib_data_dir
|
'/home/brenainn/.pyenv/versions/3.9.6/lib/python3.9/site-packages/matplotlib/mpl-data'
|
|
Functions may take positional and keyword arguments and return most generic Python data types. ::
|
|
>>> def echo_parameters(*args, **kwargs):
|
... return args, kwargs
|
>>> isolated.call(echo_parameters, 1, 2, 3)
|
(1, 2, 3), {}
|
>>> isolated.call(echo_parameters, foo=["bar"])
|
(), {'foo': ['bar']}
|
|
Notes:
|
To make a function behave differently if it's isolated, check for the ``__isolated__`` global. ::
|
|
if globals().get("__isolated__", False):
|
# We're inside a child process.
|
...
|
else:
|
# This is the master process.
|
...
|
|
N)rG rp )rk rl rm Úisolatedr r r rp 9 s :rp c s t ¡ fdd}|S )aã
|
Decorate a function so that it is always called in an isolated subprocess.
|
|
Examples:
|
|
To use, write a function then prepend ``@isolated.decorate``. ::
|
|
@isolated.decorate
|
def add_1(x):
|
'''Add 1 to ``x``, displaying the current process ID.'''
|
import os
|
print(f"Process {os.getpid()}: Adding 1 to {x}.")
|
return x + 1
|
|
The resultant ``add_1()`` function can now be called as you would a
|
normal function and it'll automatically use a subprocess.
|
|
>>> add_1(4)
|
Process 4920: Adding 1 to 4.
|
5
|
>>> add_1(13.2)
|
Process 4928: Adding 1 to 13.2.
|
14.2
|
|
c s t f| |S r* )rp )rl rm ©rk r r Úwrapped s zdecorate.<locals>.wrapped)Ú functoolsÚwraps)rk ru r rt r Údecoratew s rx )3r& Úpathlibr Úmarshalr r Úbase64r r rv r8 rT Z PyInstallerr r ÚloggingÚ getLoggerr r_ r6 rO r Zctypes.wintypesÚ Structurer
|
ZHANDLE_FLAG_INHERITÚPOINTERZLPSECURITY_ATTRIBUTESÚwindllÚkernel32r# r r! r Úargtypesr Úrestyper+ Ú__file__Ú with_namer; r r r r Úintr@ r7 rG rp rx r r r r Ú<module> sP
|
|
|
ü
|
|
|
|
>
|
