File: //usr/lib/python3/dist-packages/twisted/internet/__pycache__/process.cpython-38.pyc
U
�bt� � @ s� U d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
m Z m Z ddl
mZ ddlmZmZmZ ddlmZ ddlmZ ddlmZmZ dd lmZm Z dd
l m Z dd l m Z e �!� r�e"d ��z ddl#Z$W n e"k
r� dZ#Y nX e$Z#zddl%Z&ddl'Z'W n e"k
�r2 dZ%Y nX e&Z%ej(Z(i Z)e e*e
f e+d
< dd� Z,dd� Z-dd� Z.G dd� dej/�Z0G dd� dej/�Z1G dd� de�Z2G dd� d�Z3e3� Z4d d � Z5ee�G d d � d e2��Z6ee�G d d!� d!ej/e2��Z7dS )"z�
UNIX Process management.
Do NOT use this module directly - use reactor.spawnProcess() instead.
Maintainer: Itamar Shtull-Trauring
� N)�Callable�Dict�Optional)� implementer)�abstract�error�fdesc)� BaseProcess)�IProcessTransport)�CONNECTION_DONE�CONNECTION_LOST)�failure�log)�platform)� switchUIDz^twisted.internet.process does not work on Windows. Use the reactor.spawnProcess() API instead.�reapProcessHandlersc C s t t�� �D ] } | �� q dS )z(
Reap all registered processes.
N)�listr �values� reapProcess)�process� r �:/usr/lib/python3/dist-packages/twisted/internet/process.py�reapAllProcesses= s r c C s� | t krtd��zt�| tj�\}}W n@ tk
rf t�d| � d�� t�� | dkr^Y dS d}Y nX |rx|� |� n|t | < dS )z�
Register a process handler for the given pid, in case L{reapAllProcesses}
is called.
@param pid: the pid of the process.
@param process: a process handler.
z.Try to register an already registered process.�Failed to reap �:N)
r � RuntimeError�os�waitpid�WNOHANG�
BaseExceptionr �msg�err� processEnded)�pidr ZauxPID�statusr r r �registerReapProcessHandlerG s
r% c C s& | t krt | |ks td��t | = dS )zd
Unregister a process handler previously registered with
L{registerReapProcessHandler}.
z+Try to unregister a process not registered.N)r r )r# r r r r � unregisterReapProcessHandlerb s r& c @ sN e Zd ZdZdZdZdZddd�Zdd� Zd d
� Z d d � Z
d
d� Z dd� Z dS )�
ProcessWritera�
(Internal) Helper class to write into a Process's input pipe.
I am a helper which describes a selectable asynchronous writer to a
process's input pipe, including stdin.
@ivar enableReadHack: A flag which determines how readability on this
write descriptor will be handled. If C{True}, then readability may
indicate the reader for this write descriptor has been closed (ie,
the connection has been lost). If C{False}, then readability events
are ignored.
� r Fc C s� t j�| |� t�|� || _|| _|| _t� t
� | � � �j
�sHd| _n<|rTd| _n0zt
�| � � d� W n tk
r� d| _Y nX | jr�| �� dS )zJ
Initialize, specifying a Process instance to connect to.
FTr N)r �FileDescriptor�__init__r �setNonBlocking�proc�name�fd�stat�S_ISFIFOr �fstat�fileno�st_mode�enableReadHack�read�OSError� startReading)�self�reactorr, r- r2 �
forceReadHackr r r r* ~ s
zProcessWriter.__init__c C s | j S )z<
Return the fileno() of my process's stdin.
�r. �r8 r r r r2 � s zProcessWriter.filenoc C s, t �| j|�}|t|�kr(| jr(| �� |S �z6
Write some data to the open process.
)r � writeToFDr. �lenr4 r7 )r8 �data�rvr r r �
writeSomeData� s zProcessWriter.writeSomeDatac C s | � � tj�| |� d S �N)� stopReadingr r) �write�r8 r@ r r r rE � s zProcessWriter.writec C s | j r
tS | �� dS )a�
The only way a write pipe can become "readable" is at EOF, because the
child has closed it, and we're using a reactor which doesn't
distinguish between readable and closed (such as the select reactor).
Except that's not true on linux < 2.6.11. It has the following
characteristics: write pipe is completely empty => POLLOUT (writable in
select), write pipe is not completely empty => POLLIN (readable in
select), write pipe's reader closed => POLLIN|POLLERR (readable and
writable in select)
That's what this funky code is for. If linux was not broken, this
function could be simply "return CONNECTION_LOST".
N)r4 r rD r< r r r �doRead� s zProcessWriter.doReadc C s. t �| j� tj�| |� | j�| j|� dS )z=
See abstract.FileDescriptor.connectionLost.
N) r � setBlockingr. r r) �connectionLostr, �childConnectionLostr- �r8 �reasonr r r rI � s z ProcessWriter.connectionLostN)F)
�__name__�
__module__� __qualname__�__doc__� connectedZicr4 r* r2 rB rE rG rI r r r r r' l s
r' c @ sL e Zd ZdZdZdd� Zdd� Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dS )�
ProcessReaderzx
ProcessReader
I am a selectable representation of a process's output pipe, such as
stdout and stderr.
Tc C s6 t j�| |� t�|� || _|| _|| _| �� dS )zA
Initialize, specifying a process to connect to.
N) r r) r* r r+ r, r- r. r7 )r8 r9 r, r- r2 r r r r* � s
zProcessReader.__init__c C s | j S )z=
Return the fileno() of my process's stderr.
r; r< r r r r2 � s zProcessReader.filenoc C s |dks t �tS )N� )�AssertionErrorr rF r r r rB � s zProcessReader.writeSomeDatac C s t �| j| j�S )z@
This is called when the pipe becomes readable.
)r �
readFromFDr. � dataReceivedr< r r r rG � s zProcessReader.doReadc C s | j �| j|� d S rC )r, �childDataReceivedr- rF r r r rV � s zProcessReader.dataReceivedc C s6 | j r2| js2d| _| �� | j�d| jt�t�� d S )Nr( r ) rQ �
disconnectingrD r9 � callLaterrI r
�Failurer r< r r r �loseConnection� s �z ProcessReader.loseConnectionc C s" t j�| |� | j�| j|� dS )zk
Close my end of the pipe, signal the Process (which signals the
ProcessProtocol).
N)r r) rI r, rJ r- rK r r r rI s z ProcessReader.connectionLostN) rM rN rO rP rQ r* r2 rB rG rV r[ rI r r r r rR � s rR c @ sl e Zd ZU dZdZee ed< dZdd� Z dd� Z
dd � Z d
d � Z d d
� Z
dd� Zdd� Zed�dd�ZdS )� _BaseProcessz0
Base class for Process and PTYProcess.
Nr$ c
C s� zTzt �| jt j�\}}W n6 tk
rP } z|jtjkr>d}n� W 5 d}~X Y nX W n4 tk
r� t� d| j� d�� t�
� d}Y nX |r�t || � | � |� dS )a
Try to reap a process (without blocking) via waitpid.
This is called when sigchild is caught or a Process object loses its
"connection" (stdout is closed) This ought to result in reaping all
zombie processes, since it will be called twice as often as it needs
to be.
(Unfortunately, this is a slightly experimental approach, since
UNIX has no way to be really sure that your process is going to
go away w/o blocking. I don't want to block.)
Nr r )
r r r# r r6 �errnoZECHILDr r r r! r& r" )r8 r# r$ �er r r r s
z_BaseProcess.reapProcessc C sH d }}t �|�r t �|�}n
t �|�}|s0|r>t�|||�S t�|�S rC )r � WIFEXITED� WEXITSTATUS�WTERMSIGr �ProcessTerminated� ProcessDone)r8 r$ �exitCode�sigr r r �
_getReason6 s
z_BaseProcess._getReasonc
C sx |dkrt td|� ��}| jdkr(t� �zt�| j|� W n8 tk
rr } z|jtjkr`t� �n� W 5 d}~X Y nX dS )a*
Send the given signal C{signalID} to the process. It'll translate a
few signals ('HUP', 'STOP', 'INT', 'KILL', 'TERM') from a string
representation to its int value, otherwise it'll pass directly the
value provided
@type signalID: C{str} or C{int}
)ZHUP�STOP�INTZKILLZTERMZSIGN) �getattr�signalr# �ProcessExitedAlreadyr �killr6 r] �ESRCH)r8 �signalIDr^ r r r �
signalProcess@ s
z_BaseProcess.signalProcessc C s4 t dtj�D ]"}t�|�tjkr t�|tj� q d S �Nr( )�rangerj �NSIG� getsignal�SIG_IGN�SIG_DFL)r8 � signalnumr r r �_resetSignalDispositionU s z$_BaseProcess._resetSignalDispositionc K s4 t �� }t �� zt�� | _W n" tk
r@ |r:t �� � Y n�X | jdk�r z.t� d� | j
f |� | � ||||||� W n� tk
�r zft j
t�dd�dd�} d�|t|�t|��}
| �|
� tj| d� | �� td �D ]} t�| � q�W n tk
�r
Y nX Y nX t�d
� |�r*t �� d | _dS ) a�
Fork and then exec sub-process.
@param path: the path where to run the new process.
@type path: L{bytes} or L{unicode}
@param uid: if defined, the uid used to run the new process.
@type uid: L{int}
@param gid: if defined, the gid used to run the new process.
@type gid: L{int}
@param executable: the executable to run in a new process.
@type executable: L{str}
@param args: arguments used to create the new process.
@type args: L{list}.
@param environment: environment used for the new process.
@type environment: L{dict}.
@param kwargs: keyword arguments to L{_setupChild} method.
r N� �wbzutf-8)�encodingz)Upon execvpe {} {} in environment id {}
:��file� r( ���)�gc� isenabled�disabler �forkr# r �enable�sys�settrace� _setupChild�
_execChild�io�
TextIOWrapper�fdopen�format�str�idrE � traceback� print_exc�flushrq �close�_exitr$ ) r8 �path�uid�gid�
executable�args� environment�kwargsZcollectorEnabled�stderrr r. r r r �_fork` s@
�
z_BaseProcess._forkc O s
t � �dS )zB
Setup the child process. Override in subclasses.
N��NotImplementedError)r8 r� r� r r r r� � s z_BaseProcess._setupChildc C sn |rt �|� |dk s |dk r\|dkr.t �� }|dkr>t �� }t �d� t �d� t||� t �|||� dS )z?
The exec() which is done in the forked child.
Nr )r �chdir�geteuid�getegid�setuid�setgidr �execvpe)r8 r� r� r� r� r� r� r r r r� � s
z_BaseProcess._execChild)�returnc C s d� | jj| j| j�S )z5
String representation of a process.
z<{} pid={} status={}>)r� � __class__rM r# r$ r< r r r �__repr__� s
�z_BaseProcess.__repr__)rM rN rO rP r$ r �int�__annotations__r# r rf ro rw r� r� r� r� r� r r r r r\ s
_r\ c @ sP e Zd ZdZejZejZeZdd� Z dd� Z
dd� Z dd � Z d
d � Z
d d
� ZdS )� _FDDetectorav
This class contains the logic necessary to decide which of the available
system techniques should be used to detect the open file descriptors for
the current process. The chosen technique gets monkey-patched into the
_listOpenFDs method of this class so that the detection only needs to occur
once.
@ivar listdir: The implementation of listdir to use. This gets overwritten
by the test cases.
@ivar getpid: The implementation of getpid to use, returns the PID of the
running process.
@ivar openfile: The implementation of open() to use, by default the Python
builtin.
c C s | j | j| jg| _d S rC )�_procFDImplementation�_devFDImplementation�_fallbackFDImplementation�_implementationsr< r r r r* � s �z_FDDetector.__init__c C s | � � | _| �� S )z�
Return an iterable of file descriptors which I{may} be open in this
process.
This will try to return the fewest possible descriptors without missing
any.
)�_getImplementation� _listOpenFDsr< r r r r� � s
z_FDDetector._listOpenFDsc
C sb | j D ]V}z
|� }W n tk
r, Y qY nX | �dd�� |� }W 5 Q R X ||kr| S q|S )a�
Pick a method which gives correct results for C{_listOpenFDs} in this
runtime environment.
This involves a lot of very platform-specific checks, some of which may
be relatively expensive. Therefore the returned method should be saved
and re-used, rather than always calling this method to determine what it
is.
See the implementation for the details of how a method is selected.
z /dev/null�r)r� r �openfile)r8 �impl�before�afterr r r r� s
z _FDDetector._getImplementationc C s d}dd� | � |�D �}|S )z�
Simple implementation for systems where /dev/fd actually works.
See: http://www.freebsd.org/cgi/man.cgi?fdescfs
z/dev/fdc S s g | ] }t |��qS r �r� ��.0r. r r r �
<listcomp>+ s z4_FDDetector._devFDImplementation.<locals>.<listcomp>)�listdir)r8 �dname�resultr r r r� % s z _FDDetector._devFDImplementationc C s" d| � � f }dd� | �|�D �S )zk
Simple implementation for systems where /proc/pid/fd exists (we assume
it works).
z /proc/%d/fdc S s g | ] }t |��qS r r� r� r r r r� 4 s z5_FDDetector._procFDImplementation.<locals>.<listcomp>)�getpidr� )r8 r� r r r r� . s z!_FDDetector._procFDImplementationc C sD z ddl }W n tk
r$ d}Y nX td|�|j�d �}t|�S )au
Fallback implementation where either the resource module can inform us
about the upper bound of how many FDs to expect, or where we just guess
a constant maximum if there is no resource module.
All possible file descriptors from 0 to that upper bound are returned
with no attempt to exclude invalid file descriptor values.
r Ni r( )�resource� ImportError�minZ getrlimitZ
RLIMIT_NOFILErq )r8 r� Zmaxfdsr r r r� 6 s
z%_FDDetector._fallbackFDImplementationN)rM rN rO rP r r� r� �openr� r* r� r� r� r� r� r r r r r� � s r� c C s t �� S )zZ
Use the global detector object to figure out which FD implementation to
use.
)�detectorr� r r r r r� N s r� c @ s� e Zd ZdZdZdZdZdZeZ e
Z d+dd�Z dd� Z
d d
� Zd d � Zd
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Z d'd(� Z d)d*� Z dS ),�Processa�
An operating-system Process.
This represents an operating-system process with arbitrary input/output
pipes connected to it. Those pipes may represent standard input,
standard output, and standard error, or any other file descriptor.
On UNIX, this is implemented using fork(), exec(), pipe()
and fcntl(). These calls may not exist elsewhere so this
code is not cross-platform. (also, windows can only select
on sockets...)
Fr~ Nc
sd |s$d| � � kst�d| � � ks$t�t�| |� i | _i }
| dkrNdddd�} | j} | rbtd| � g � � fdd�} i }
z�| �� D ]�\}}| r�td| |� |dkr�| � \}}| r�td ||f � ||
|< ||
|< q�|dk�r | � \}}| r�td ||f � ||
|< ||
|< q�t|�t k�s(t|�d
���||
|< q�| �rBtd |
� | �rRtd |
� | j
|||||||
d
� W n. t k
�r� � D ]} t �
| � �q�� Y nX || _|
�� D ]l\}}t �
|
| � | | dk�r�| �|| ||�}|| j|< | | dk�r�| j|| ||dd�}|| j|< �q�z | jdk �r2| j�| � W n t k
�rR t�� Y nX t| j| � dS )�
Spawn an operating-system process.
This is where the hard work of disconnecting all currently open
files / forking / executing the new process happens. (This is
executed automatically when a Process is instantiated.)
This will also run the subprocess as a given user ID and group ID, if
specified. (Implementation Note: this doesn't support all the arcane
nuances of setXXuid on UNIX: it will assume that either your effective
or real UID is 0.)
r� �wN)r r( rx �childFDsc s" t �� \} }� �| |g� | |fS rC )r �pipe�extend)r� r� �Z _openedPipesr r r� � s z Process.__init__.<locals>.pipez[%d]zreadFD=%d, writeFD=%dz should be an int�fdmap�helpers)r� T)r: )r rT r\ r* �pipes�debug�print�items�typer� r� r r r� �proto�processReaderFactory�processWriterFactory�makeConnectionr r! r% r# )r8 r9 r� r� r� r� r� r� r� r� r� r� r� r� �childFD�targetZreadFDZwriteFDZparentFD�reader�writerr r� r r* n s� �
� zProcess.__init__c C s� | j }|rtj}|�d� |�� }t� D ]D}||kr6q(|rH||�� krHq(zt�|� W q( t k
rj Y q(X q(|r�t
d||d� t |� � �D ]�}|| }||kr�|r�t
d| |d� t
�|� q�||�� k�r$t�|�}|r�t
d||f |d� t�|� t|�� �D ] \} }
|
|k�r||| < �q|�r>t
d||f |d� t�||� q�g } |�� D ](}|| k�rX||� � k�rX| �|� �qX|�r�t
d| |d� | D ]}t�|� �q�| �� dS ) a
fdmap[childFD] = parentFD
The child wants to end up with 'childFD' attached to what used to be
the parent's parentFD. As an example, a bash command run like
'command 2>&1' would correspond to an fdmap of {0:0, 1:1, 2:1}.
'command >foo.txt' would be {0:0, 1:os.open('foo.txt'), 2:2}.
This is accomplished in two steps::
1. close all file descriptors that aren't values of fdmap. This
means 0 .. maxfds (or just the open fds within that range, if
the platform supports '/proc/<pid>/fd').
2. for each childFD::
- if fdmap[childFD] == childFD, the descriptor is already in
place. Make sure the CLOEXEC flag is not set, then delete
the entry from fdmap.
- if childFD is in fdmap.values(), then the target descriptor
is busy. Use os.dup() to move it elsewhere, update all
fdmap[childFD] items that point to it, then close the
original. Then fall through to the next case.
- now fdmap[childFD] is not in fdmap.values(), and is free.
Use os.dup2() to move it to the right place, then close the
original.
zstarting _setupChild
r� r{ z%d already in placezos.dup(%d) -> %dzos.dup2(%d,%d)�oldN)� debug_childr� r� rE r r� r2 r r� r r� �sorted�keysr �_unsetCloseOnExec�dupr r� �dup2�appendrw ) r8 r� r� ZerrfdZdestListr. �childr� Z newtarget�c�pr� r r r r� � sV
zProcess._setupChildc C s | j | �|� d S rC �r� rE �r8 r� r@ r r r � writeToChildE s zProcess.writeToChildc C s || j kr| j | �� d S rC )r� r[ )r8 r� r r r � closeChildFDH s
zProcess.closeChildFDc C s& | j �� D ]}t|t�r
|�� q
d S rC )r� r �
isinstancerR rD �r8 r� r r r �pauseProducingP s
zProcess.pauseProducingc C s& | j �� D ]}t|t�r
|�� q
d S rC )r� r r� rR r7 r� r r r �resumeProducingU s
zProcess.resumeProducingc C s | � d� dS )zD
Call this to close standard input on this process.
r N�r� r< r r r �
closeStdin[ s zProcess.closeStdinc C s | � d� d S rp r� r< r r r � closeStdouta s zProcess.closeStdoutc C s | � d� d S �Nrx r� r< r r r � closeStderrd s zProcess.closeStderrc C s | � � | �� | �� d S rC )r� r� r� r< r r r r[ g s zProcess.loseConnectionc C s d| j kr| j d �|� dS �z�
Call this to write to standard input on this process.
NOTE: This will silently lose data if there is no standard input.
r Nr� rF r r r rE l s
z
Process.writec C s* d| j kr | j d �||� n|�� dS )z�
Call this to register producer for standard input.
If there is no standard input producer.stopProducing() will
be called immediately.
r N)r� �registerProducer�
stopProducing)r8 �producer� streamingr r r r� u s
zProcess.registerProducerc C s d| j kr| j d �� dS )z=
Call this to unregister producer for standard input.r N)r� �unregisterProducerr< r r r r� � s
zProcess.unregisterProducerc C s d| j kr| j d �|� dS r� )r� �
writeSequence)r8 �seqr r r r� � s
zProcess.writeSequencec C s | j �||� d S rC �r� rW )r8 r- r@ r r r rW � s zProcess.childDataReceivedc C sV t �| j| �� � | j|= z| j�|� W n tk
rH t�� Y nX | � � d S rC )
r r� r� r2 r� rJ r r r! �maybeCallProcessEnded)r8 r� rL r r r rJ � s zProcess.childConnectionLostc C s* | j r
d S | js | �� d S t�| � d S rC )r� � lostProcessr r\ r� r< r r r r� � s z Process.maybeCallProcessEndedc C s
t � �d S rC r� r< r r r �getHost� s zProcess.getHostc C s
t � �d S rC r� r< r r r �getPeer� s zProcess.getPeer)NNN) rM rN rO rP r� r� r$ r# r' r� rR r� r* r� r� r� r� r� r� r� r� r[ rE r� r� r� rW rJ r� r� r� r r r r r� V s:
�
w`
r� c @ sz e Zd ZdZdZdZd dd�Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� ZdS ) �
PTYProcessz<
An operating-system Process that uses PTY support.
r~ Nc
C s$ t dkr t| ttf�s td��tj�| |� t�| |� t| ttf�rR| \}
} } n t � � \}
} z | j
|||||||
| d� W n8 t k
r� t| ttf�s�t �
|
� t �
| � � Y nX t �
| � t�|
� |
| _| �� d| _d| _z| j�| � W n t k
�r t�� Y nX t| j| � dS )r� Nz:cannot use PTYProcess on platforms without the pty module.)�masterfd�slavefdr( r~ )�ptyr� �tupler r� r r) r* r\ �openptyr� r r r� r r+ r. r7 rQ r$ r� r� r r! r% r# )
r8 r9 r� r� r� r� r� r� r� �usePTYr� r� �_r r r r* � sH � �
zPTYProcess.__init__c C s� t �|� t �� t�|tjd� td�D ]}||kr*t �|� q*t �|d� t �|d� t �|d� t � D ]0}|dkrlzt �|� W ql t
k
r� Y qlX ql| � � dS )a9
Set up child process after C{fork()} but before C{exec()}.
This involves:
- closing C{masterfd}, since it is not used in the subprocess
- creating a new session with C{os.setsid}
- changing the controlling terminal of the process (and the new
session) to point at C{slavefd}
- duplicating C{slavefd} to standard input, output, and error
- closing all other open file descriptors (according to
L{_listOpenFDs})
- re-setting all signal handlers to C{SIG_DFL}
@param masterfd: The master end of a PTY file descriptors opened with
C{openpty}.
@type masterfd: L{int}
@param slavefd: The slave end of a PTY opened with C{openpty}.
@type slavefd: L{int}
� r} r r( rx N) r r� �setsid�fcntl�ioctl�termiosZ TIOCSCTTYrq r� r� r rw )r8 r� r� r. r r r r� s
zPTYProcess._setupChildc C s d S rC r r< r r r r� 0 s zPTYProcess.closeStdinc C s d S rC r r< r r r r� 5 s zPTYProcess.closeStdoutc C s d S rC r r< r r r r� 8 s zPTYProcess.closeStderrc s t �� j� fdd��S )zM
Called when my standard output stream is ready for reading.
c s � j �d| �S rp r� )r@ r< r r �<lambda>@ rS z#PTYProcess.doRead.<locals>.<lambda>)r rU r. r< r r< r rG ; s
�zPTYProcess.doReadc C s | j S )zR
This returns the file number of standard output on this process.
r; r< r r r r2 C s zPTYProcess.filenoc C s | j dkrt�| � d S r� )r� r\ r� r< r r r r� I s
z PTYProcess.maybeCallProcessEndedc C s4 t j�| |� t�| j� | jd7 _| �� dS )zU
I call this to clean up when one or all of my connections has died.
r( N)r r) rI r r� r. r� r� rK r r r rI S s zPTYProcess.connectionLostc C s t �| j|�S r= )r r> r. rF r r r rB \ s zPTYProcess.writeSomeDatac C s
t � �d S rC r� )r8 �
descriptorr r r r� b s zPTYProcess.closeChildFDc C s
t � �d S rC r� r� r r r r� f s zPTYProcess.writeToChild)NNN)rM rN rO rP r$ r# r* r� r� r� r� rG r2 r� rI rB r� r� r r r r r� � s$
�
C0
r� )8rP r] r r� r rj r/ r� r� �typingr r r �zope.interfacer �twisted.internetr r r Z twisted.internet._baseprocessr �twisted.internet.interfacesr
�twisted.internet.mainr r �twisted.pythonr
r �twisted.python.runtimer �twisted.python.utilr � isWindowsr� r Z_ptyr �_fcntlr rk r r� r� r r% r& r) r' rR r\ r� r� r� r� r� r r r r �<module> sd �
h< Rj _