h.%SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK J r SSK JrJrJrJrJr S\S'S\S'\(d SS KJrJr SS KJr SS KJrJrJr SS KJ r SS K!J"r" SSK#J$r$J%r% SSK&J'r'J(r( SSK)J*r* SSK+J,r, \*RZ"5(a\"S5eSSK.r/\/r.SSK0r1SSK2r2\1r0\Rfr30r4S\S'S&Sjr5Sr6Sr7"SS\Rp5r9"SS\Rp5r:"SS\ 5r;"SS5r<\<"5r=S r>S'S!jr?\"\"5"S"S#\;55r@\"\"5"S$S%\Rp\;55rAg!\a GNf=f!\a Sr.Nf=f!\a Sr0Nf=f)(z UNIX Process management. Do NOT use this module directly - use reactor.spawnProcess() instead. Maintainer: Itamar Shtull-Trauring ) annotationsN) defaultdict) TYPE_CHECKINGDictListOptionalTupleint _PS_CLOSE_PS_DUP2)POSIX_SPAWN_CLOSEPOSIX_SPAWN_DUP2) implementer)abstracterrorfdesc) BaseProcess)IProcessTransport)CONNECTION_DONECONNECTION_LOST)failurelog)platform) switchUIDz^twisted.internet.process does not work on Windows. Use the reactor.spawnProcess() API instead.zDict[int, _BaseProcess]reapProcessHandlerscl[[R55HnUR5 M g)z Reap all registered processes. N)listrvalues reapProcess)processs _/root/1688_scrapy/alibaba-scraper/venv/lib/python3.13/site-packages/twisted/internet/process.pyreapAllProcessesr"Hs) +22456cNU[;a [S5e[R"U[R5up#U(aURW5 gU[U'g![ a9 [ R"SUS35 [ R"5 UcgSnNef=f)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 RuntimeErroroswaitpidWNOHANG BaseExceptionrmsgerr processEnded)pidr auxPIDstatuss r!registerReapProcessHandlerr2Rs !!KLL C4V$$+C   /#a()  ; s'A!!s+Cw+NHIIC r#cL\rSrSrSrSrSrSrSSjrSr Sr S r S r S r S rg ) ProcessWriterwa (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. rFc [RRX5 [R"U5 X lX0lX@l[R"[R"UR55R5(dSUlO5U(aSUlO&[R"UR5S5 UR(aUR#5 gg![ a SUlN6f=f)z: Initialize, specifying a Process instance to connect to. FTrN)rFileDescriptor__init__rsetNonBlockingprocnamefdstatS_ISFIFOr(fstatfilenost_modeenableReadHackreadOSError startReading)selfreactorr=r>rC forceReadHacks r!r;ProcessWriter.__init__s ((7 V$  }}RXXdkkm4<<==#(D  "&D   + q)          +&*# +s'%C//DDcUR$)z, Return the fileno() of my process's stdin. r?rIs r!rCProcessWriter.fileno wwr#c[R"URU5nU[U5:Xa!UR(aUR 5 U$z& Write some data to the open process. )r writeToFDr?lenrErH)rIdatarvs r! writeSomeDataProcessWriter.writeSomeDatas>__TWWd + T?t22     r#cbUR5 [RRX5 gN) stopReadingrr:writerIrVs r!r]ProcessWriter.writes" %%d1r#cRUR(a[$UR5 g)ad 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)rErr\rOs r!doReadProcessWriter.doReads   " "    r#c[R"UR5 [RR X5 UR RURU5 g)z- See abstract.FileDescriptor.connectionLost. N) r setBlockingr?rr:connectionLostr=childConnectionLostr>rIreasons r!reProcessWriter.connectionLostsB $''"..t< %%dii8r#)rEr?r>r=N)F)__name__ __module__ __qualname____firstlineno____doc__ connectedicrEr;rCrXr]rare__static_attributes__r#r!r6r6ws6 I BN > 2( 9r#r6cF\rSrSrSrSrSrSrSrSr Sr S r S r S r g ) ProcessReaderzh ProcessReader I am a selectable representation of a process's output pipe, such as stdout and stderr. Tc[RRX5 [R"U5 X lX0lX@lUR5 g)z1 Initialize, specifying a process to connect to. N) rr:r;rr<r=r>r?rH)rIrJr=r>rCs r!r;ProcessReader.__init__sA ((7 V$   r#cUR$)z- Return the fileno() of my process's stderr. rNrOs r!rCProcessReader.filenorQr#cUS:Xde[$)Nr#)rr^s r!rXProcessReader.writeSomeDatass{{r#cX[R"URUR5$)z0 This is called when the pipe becomes readable. )r readFromFDr? dataReceivedrOs r!raProcessReader.doReads!):):;;r#cPURRURU5 gr[)r=childDataReceivedr>r^s r!r~ProcessReader.dataReceiveds ##DIIt4r#cUR(aiUR(dWSUlUR5 URR SUR [ R"[55 ggg)Nr8r) ro disconnectingr\rJ callLaterrerFailurerrOs r!loseConnectionProcessReader.loseConnection sT >>$"4"4!"D      LL " "4&&(H #5>r#c[RRX5 URR UR U5 g)zS Close my end of the pipe, signal the Process (which signals the ProcessProtocol). N)rr:rer=rfr>rgs r!reProcessReader.connectionLosts0 ..t< %%dii8r#)rr?r>r=N)rjrkrlrmrnror;rCrXrar~rrerqrrr#r!rtrts1I  < 59r#rtcf\rSrSr%SrSrS\S'SrSrSr Sr S r S r S r S rS rSSjrSrg) _BaseProcessiz( Base class for Process and PTYProcess. Nz Optional[int]r1c[R"UR[R5upU(a[X5 URW5 gg![a+nUR [ R :XaSnSnANTeSnAff=f![a> [R"SURS35 [R"5 SnNf=f)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*rGerrnoECHILDr+rr,r-r4r.)rIr/r1es r!r_BaseProcess.reapProcess#s   jj2::>   ( 3   f %  77ell*C     GGodhhZq1 2 GGIC s61A B# B BB  BBACCcS=p#[R"U5(a[R"U5nO[R"U5nU(dU(a[R "X#U5$[R "U5$r[)r( WIFEXITED WEXITSTATUSWTERMSIGrProcessTerminated ProcessDone)rIr1exitCodesigs r! _getReason_BaseProcess._getReasonAs^ <<  ~~f-H++f%C s**8&A A  ((r#cUS;a[[SU35nURc [5e[R "URU5 g![ a.nUR[R:Xa [5eeSnAff=f)z 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} )HUPSTOPINTKILLTERMSIGN) getattrsignalr/ProcessExitedAlreadyr(killrGrESRCH)rIsignalIDrs r! signalProcess_BaseProcess.signalProcessKsv = =vXJ'78H 88 &( (  GGDHHh ' ww%++%*,,  s!A B )BB c[S[R5HRn[R"U5[R:XdM-[R"U[R 5 MT gNr8)rangerNSIG getsignalSIG_IGNSIG_DFL)rI signalnums r!_resetSignalDisposition$_BaseProcess._resetSignalDisposition`sB q&++.I *fnn< i8/r#cg)a Try to use posix_spawnp() instead of fork(), if possible. This implementation returns False because the non-PTY subclass implements the actual logic; we can't yet use this for pty processes. @return: a boolean indicating whether posix_spawnp() was used or not. Frr)rIpathuidgid executableargs environmentkwargss r!_trySpawnInsteadOfFork#_BaseProcess._trySpawnInsteadOfForkksr#c URXX4XVU5(ag[R"5n[R"5 [R "5UlUR S:XaR[R"S5 UR"S 0UD6 URXX4XV5 [R0"S 5 U(a[R2"5 S Ulg![a [R"[R"SS5SS9n SRU[!U5[#U55n U R%U 5 [&R("U S9 U R+5 [-S 5Hn [R."U 5 M N![a GNf=ff=f![a U(a[R2"5 ef=f) aN 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. Nrwbzutf-8)encodingz)Upon execvpe {} {} in environment id {} :filer8rr)rgc isenableddisabler(forkr/syssettrace _setupChild _execChildr+io TextIOWrapperfdopenformatstridr] traceback print_excflushrclose_exitenabler1) rIrrrrrrrcollectorEnabledstderrr,r?s r!_fork_BaseProcess._forkxsv2  & & s6   <<> D wwyDHxx1}+LL&$$.v.OODsRV   IIK _%&""$!1!1"))At2Dw!WNVV&D 2k? S)!++8 "'(BHHRL#+(G&1    s7F51;C&& F21B,F F.)F2-F..F25(Gc[5e)z2 Setup the child process. Override in subclasses. NotImplementedError)rIrrs r!r_BaseProcess._setupChilds "##r#cFU(a[R"U5 UcUbgUc[R"5nUc[R"5n[R"S5 [R "S5 [ X#5 [R"XEU5 g)z/ The exec() which is done in the forked child. Nr)r(chdirgeteuidgetegidsetuidsetgidrexecvpe)rIrrrrrrs r!r_BaseProcess._execChildsg  HHTN ?co{jjl{jjl IIaL IIaL c  :[1r#cxSRURRURUR5$)z% String representation of a process. z<{} pid={} status={}>)r __class__rjr/r1rOs r!__repr___BaseProcess.__repr__s2'-- NN # # HH KK  r#)r/r1)returnr)rjrkrlrmrnr1__annotations__r/rrrrrrrrrrqrrr#r!rrsG!FM C&<)* 9 iV$ 2" r#rcp\rSrSrSr\R r\Rr\r Sr Sr Sr Sr SrSrS rg ) _FDDetectoriaF 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. cTURURUR/Ulgr[)_procFDImplementation_devFDImplementation_fallbackFDImplementation_implementationsrOs r!r;_FDDetector.__init__s'  & &  % %  * *! r#cLUR5UlUR5$)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 _listOpenFDsrOs r!r_FDDetector._listOpenFDs!s$!335  ""r#cURH7nU"5nURSS5 U"5nSSS5 UW:wdM5Us $ W$![a MJf=f!,(df  N/=f)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/nullrN)rr+openfile)rIimplbeforeafters r!r_FDDetector._getImplementation,sj))D {C01 * !  00sA A AA A) chSnURU5Vs/sHn[U5PM nnU$s snf)zq Simple implementation for systems where /dev/fd actually works. See: http://www.freebsd.org/cgi/man.cgi?fdescfs z/dev/fd)listdirr )rIdnamer?results r!r _FDDetector._devFDImplementationIs6 $(LL$78$7b#b'$78 9s/cSUR54-nURU5Vs/sHn[U5PM sn$s snf)zS Simple implementation for systems where /proc/pid/fd exists (we assume it works). z /proc/%d/fd)getpidrr )rIrr?s r!r!_FDDetector._procFDImplementationRs>  00"&,,u"56"5BB"5666sAcSSKn[SURUR5S5n[ U5$![a SnNf=f)aE 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. rNir8)resourcemin getrlimit RLIMIT_NOFILE ImportErrorr)rIr maxfdss r!r%_FDDetector._fallbackFDImplementationZsO N x11(2H2HI!LMFV} F s9 AA)rrN)rjrkrlrmrnr(rr openrr;rrrrrrqrrr#r!rrs>  jjG YYFH  #:7r#rc*[R5$)zN Use the global detector object to figure out which FD implementation to use. )detectorrrrr#r!rrrs  ""r#cl^^[U5n[[5nUR5HupgXWR U5 M [ U5mT[ UR 55-mT[ UR55-mSmSUU4Sjjn/n 0n [UR55HupgXWRU5 XV(aU"5=oU'U R X6U 45 Xz;a8U R X:UU45 XW(dU R X*U45 MzM|Xv:Xa-XG(a"U"5n U RX7U 4XTT;a TS- mTT;aM TRT5 T$r)add) allocatednextFDsr! allocateFD#_getFileActions..allocateFDs/ ! aKF ! f r#)rr ) dictrritemsappendsetrkeyssortedremoveextend)fdStatechildToParentFDdoClosedoDup2 fdStateDictparentToChildreninChildinParentrr relocationsnewtempFDeachFD uninheritablerrs @@r!_getFileActionsr3zs"w-K-8->,224"))'25K I _++-..I _))+,,I F%'FK#O$9$9$;<"))'2  $)3 5Cg& MM6C0 1  " MM6x#8'B C#- wH(=>?."( (\FMM#v6#W5$-)* v9:C=F"-!2!2!4  ( MM7+ ,"5 Mr#c\rSrSrSrSrSrSrSr\ r \ r SSjr Sr\"\SS5cCS rS rS rS rS rSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#g)Processia 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 posix_spawnp() when possible (or fork(), exec(), pipe() and fcntl() when not). These calls may not exist elsewhere so this code is not cross-platform. (also, windows can only select on sockets...) FrNc .^XlU(d,SU R5;deSU R5;de[RX5 0Ul0n U cSSSS.n UR n U (a [ SU 5 /mU4Sjn 0n U R5HupU (a[ SU-U5 US:Xa+U "5unnU (a[ SUU4-5 UX'UX'MLUS:Xa+U "5unnU (a[ SUU4-5 UX'UX'M}[U5[:Xd U<S 35eXU'M U (a [ S U 5 U (a [ S U 5 URXWXX4U S 9 X`lU R5Hsunn[R"X5 XS:Xa"URXUU5nUURU'XS:XdMRUR!XUUS S9nUURU'Mu URbURR#U5 [)UR*U5 g![a! THn [R"U 5 M ef=f![a [$R&"5 Nff=f) 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.) rwN)rr8rchildFDsc\>[R"5upTRX/5 X4$r[)r(piper%)rr8 _openedPipess r!r;Process.__init__..pipes'779DA    '4Kr#z[%d]zreadFD=%d, writeFD=%dz should be an intfdmaphelpers)r>T)rK)_reactorrrr;pipesdebugprintrtyper rr+r(rprotoprocessReaderFactoryprocessWriterFactorymakeConnectionrr-r2r/)rIrJrrrrrErrr9r?rBr;r>childFDtargetreadFDwriteFDparentFDreaderwriterr<s @r!r;Process.__init__s0 hoo// //hoo// //d*   H    *h '    #+>>#3&7*F3S=&*fOFG58IIJ%,EN'-G$s]&*fOFG58IIJ%+EN'.G$<3.N6*r8)r(r)) file_actions setsigdefrT)r(rabspathrr@getrfcntlF_GETFD FD_CLOEXECr rGenvironrrrrr posix_spawnpr3r r r/r1)rIrrrrrrrr>r&r1 isCloseOnExec everySignal setSigDefs r!rProcess._trySpawnInsteadOfForkWsF_!(=QTAU(Ut}}&6>> 7#"nF 8 % FEMM5CSCS T 67 %  **K %Q 4 4  ,> 4  ??   ( (   /   s3E.,E?0E?. E<;E<r\c|URnU(a![RnURS5 UR 5n[ 5H>nXT;aM U(aUWR 5:XaM'[R"U5 M@ U(a [SUWS9 [UR55HnXnXv:Xa,U(a [SU-WS9 [R"U5 M8XaR 5;an[R"U5nU(a[SXh4-WS9 [R"U5 [!UR#55HupX:XdM XU 'M U(a[SXv4-WS9 [R$"Xv5 M /n UR 5H0nX[;dM XQR5;dMU R'U5 M2 U(a [SU WS9 U Hn[R"U5 M UR)5 g![a GMf=f) al 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//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>rz%d already in placezos.dup(%d) -> %dzos.dup2(%d,%d)oldN) debug_childrrr]rrrCr(rr+rCr#r"r_unsetCloseOnExecduprrdup2r r) rIr>rBerrfddestListr?childrJ newtargetcprbs r!rProcess._setupChilds<   JJE KK0 1<<>.B~u||~-  !  '5u -EJJL)E\F/&8uE''.LLN*!#u I0E3EEERHHUO $U[[] 3:'0!H!4*f_<5I&-*@,,.B}ZZ\)JJrN!  %5 )B HHRL $$&g!  s7H,, H;:H;c@URURU5 gr[rAr]rIrIrVs r! writeToChildProcess.writeToChilds 7!!$'r#c^XR;aURUR5 ggr[)rAr)rIrIs r! closeChildFDProcess.closeChildFDs( jj JJw  . . 0 !r#cURR5H*n[U[5(dMUR 5 M, gr[)rAr isinstancertr\rIrls r!pauseProducingProcess.pauseProducings/""$A!]++ %r#cURR5H*n[U[5(dMUR 5 M, gr[)rArrwrtrHrxs r!resumeProducingProcess.resumeProducings0""$A!]++ %r#c&URS5 g)z4 Call this to close standard input on this process. rNrtrOs r! closeStdinProcess.closeStdins !r#c&URS5 grrrOs r! closeStdoutProcess.closeStdout !r#c&URS5 gNrrrOs r! closeStderrProcess.closeStderr rr#cdUR5 UR5 UR5 gr[)rrrrOs r!rProcess.loseConnection s$   r#cbSUR;aURSRU5 ggzz Call this to write to standard input on this process. NOTE: This will silently lose data if there is no standard input. rNror^s r!r] Process.writes*  ? JJqM   % r#cSUR;aURSRX5 gUR5 g)z Call this to register producer for standard input. If there is no standard input producer.stopProducing() will be called immediately. rN)rAregisterProducer stopProducing)rIproducer streamings r!rProcess.registerProducers1  ? JJqM * *8 ?  " " $r#c`SUR;aURSR5 gg)z5 Call this to unregister producer for standard input.rN)rAunregisterProducerrOs r!rProcess.unregisterProducer&s(  ? JJqM , , . r#cbSUR;aURSRU5 ggr)rA writeSequence)rIseqs r!rProcess.writeSequence,s*  ? JJqM ' ' , r#c:URRX5 gr[rEr)rIr>rVs r!rProcess.childDataReceived5s $$T0r#c"[R"URUR55 URU URR U5 UR5 g![ a [R"5 N2f=fr[) r(rrArCrErfr+rr-maybeCallProcessEnded)rIrIrhs r!rfProcess.childConnectionLost8sm G$++-. JJw   JJ * *7 3 ""$  GGI sA,,B BcUR(agUR(dUR5 g[R U5 gr[)rA lostProcessrrrrOs r!rProcess.maybeCallProcessEndedCs4 ::      **40r#c[5er[rrOs r!getHostProcess.getHostP !##r#c[5er[rrOs r!getPeerProcess.getPeerTrr#)r@r/rArEr1NNN)$rjrkrlrmrnrBrcr1r/r6rGrtrFr;rrr(rrqrtryr|rrrrr]rrrrrfrrrrqrrr#r!r5r5s  EK F C((  v3p-^r>4(0 "^'@(1 !   & %/ -1 % 1$$r#r5cr\rSrSrSrSrSrSSjrSrSr Sr S r S r S r S rS rSrSrSrSrg) PTYProcessiYz4 An operating-system Process that uses PTY support. rNc \[c&[U [[45(d [ S5e[ R RX5 [RX5 [U [[45(aU upn O[R5upURUUUUUUU U S9 [R"U 5 [R"U 5 XlUR#5 SUlSUlUR(R+U5 [1UR2U5 g![aI [U [[45(d,[R"U 5 [R"U 5 ef=f![a [,R."5 Nf=f)r7Nz:cannot use PTYProcess on platforms without the pty module.)masterfdslavefdr8r)ptyrwtuplerrrr:r;ropenptyrr+r(rrr<r?rHror1rErHrr-r2r/) rIrJrrrrrErrusePTYrr_s r!r;PTYProcess.__init__bs\0 ;z&5$-@@%L  ((7d* fudm , ,#) Hq # H  JJ!  "  X&    JJ % %d + #488T2# fudm44"!     GGI sD3F 3AF F+*F+c.[R"U5 [R"5 [R U[ R S5 [S5H nX2:wdM [R"U5 M" [R"US5 [R"US5 [R"US5 [5H"nUS:dM [R"U5 M$ UR5 g![a MDf=f)a 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} rrr8rN) r(rsetsidrXioctltermios TIOCSCTTYrrfrr+r)rIrrr?s r!rPTYProcess._setupChilds6   GW..3(B}    .BAvHHRL! $$&%sD DDcgr[rrrOs r!rPTYProcess.closeStdins r#cgr[rrrOs r!rPTYProcess.closeStdout r#cgr[rrrOs r!rPTYProcess.closeStderrrr#cN^[R"TRU4Sj5$)z= Called when my standard output stream is ready for reading. c<>TRRSU5$rr)rVrIs r!#PTYProcess.doRead..s$**">">q$"Gr#)rr}r?rOs`r!raPTYProcess.doReads" GGG  r#cUR$)zB This returns the file number of standard output on this process. rNrOs r!rCPTYProcess.filenorQr#cPURS:Xa[RU5 ggr)rrrrOs r!r PTYProcess.maybeCallProcessEndeds%   q  . .t 4 !r#c[RRX5 [R"UR 5 U=R S- slUR5 g)zE I call this to clean up when one or all of my connections has died. r8N)rr:rer(rr?rrrgs r!rePTYProcess.connectionLostsE ..t<  A ""$r#cD[R"URU5$rS)rrTr?r^s r!rXPTYProcess.writeSomeDatastww--r#c[5er[r)rI descriptors r!rtPTYProcess.closeChildFDrr#c[5er[rrps r!rqPTYProcess.writeToChild rr#)ror?r1r)rjrkrlrmrnr1r/r;rrrrrarCrrerXrtrqrqrrr#r!rrYs]F C  A3F.'`     5%. $$r#r)rNone) r&zList[Tuple[int, bool]]r'zDict[int, int]r(r r)r rzList[Tuple[int, ...]])Brn __future__rrrrr(rr@rr collectionsrtypingrrrrr rr r rr rzope.interfacertwisted.internetrrrtwisted.internet._baseprocessrtwisted.internet.interfacesrtwisted.internet.mainrrtwisted.pythonrrtwisted.python.runtimertwisted.python.utilr isWindowsr_ptyrX_fcntlrrrr"r2r4r:r6rtrrrrr3r5rrrr#r!rs # #==   S'3359B'+)   6   C E11/1,1+6!e9H++e9P99H++99xg ;g TggT =#J #J#JJ  J  JZ N$lN$ N$b  s$((,s$ s$w!    * C Es6E./E;6F .E87E8;FF FF