/usr/lib/python3/dist-packages/twisted/internet/__pycache__
Edit: /usr/lib/python3/dist-packages/twisted/internet/__pycache__/cfreactor.cpython-310.pyc (15638B)
o
b[D @ s d Z ddgZddlZddlmZ ddlmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZ ddlmZmZmZmZmZmZmZmZmZmZm Z ddl m Z dd l m Z m!Z!m"Z" dd
l#m$Z$ dZ%d Z&d Z'G d
d de"Z(ee G dd de!Z)dddZ*dS )z
A reactor for integrating with U{CFRunLoop
}, the
CoreFoundation main loop used by macOS.
This is useful for integrating Twisted with U{PyObjC}
applications.
install CFReactor N) implementer) CFSocketCreateRunLoopSourceCFSocketCreateWithNativeCFSocketDisableCallBacksCFSocketEnableCallBacksCFSocketInvalidateCFSocketSetSocketFlags*kCFSocketAutomaticallyReenableReadCallBack+kCFSocketAutomaticallyReenableWriteCallBackkCFSocketConnectCallBackkCFSocketReadCallBackkCFSocketWriteCallBack) CFAbsoluteTimeGetCurrentCFRunLoopAddSourceCFRunLoopAddTimerCFRunLoopGetMainCFRunLoopRemoveSource CFRunLoopRun
CFRunLoopStopCFRunLoopTimerCreateCFRunLoopTimerInvalidatekCFAllocatorDefaultkCFRunLoopCommonModes)
IReactorFDSet) _NO_FILEDESCPosixReactorBase_Waker)log @ c @ s e Zd ZdZdd ZdS )
_WakerPlusa
The normal Twisted waker will simply wake up the main loop, which causes an
iteration to run, which in turn causes L{ReactorBase.runUntilCurrent}
to get invoked.
L{CFReactor} has a slightly different model of iteration, though: rather
than have each iteration process the thread queue, then timed calls, then
file descriptors, each callback is run as it is dispatched by the CFRunLoop
observer which triggered it.
So this waker needs to not only unblock the loop, but also make sure the
work gets done; so, it reschedules the invocation of C{runUntilCurrent} to
be immediate (0 seconds from now) even if there is no timed call work to
do.
c C s t | }| jd |S )zw
Wake up the loop and force C{runUntilCurrent} to run immediately in the
next timed iteration.
T)r doReadreactor_scheduleSimulate)selfresult r( ._drdw)r/ r r2 r r callWithLogger) r& cfSocketrI ignoredAddress ignoredDatacontextfd
smugglesrcsrcsktrL r( rH r) _socketCallback s
zCFReactor._socketCallbackc C s |dkrt d|| jv r| j| \}}}}nLg }|| tt|ttB tB | j|}t |t
t B t B t
t|d}|| t| j|t t|ttB tB ddg}|| jt|< ||||f| j|< d|| |< t|| dS )a
Register a file descriptor with the C{CFRunLoop}, or modify its state
so that it's listening for both notifications (read and write) rather
than just one; used to implement C{addReader} and C{addWriter}.
@param fd: The file descriptor.
@type fd: L{int}
@param descr: the L{IReadDescriptor} or L{IWriteDescriptor}
@param flag: the flag to register for callbacks on, either
C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack}
r< zInvalid file descriptor.r FTN) RuntimeErrorr/ appendr r r r r
rV r
r r _preserveSOErrorr r r2 r r r0 id _flag2idxr ) r& rR descrflagrT cfsgotdescrrK ctxr( r( r) _watchFD sR
zCFReactor._watchFDc C s t ttti| S )a-
Convert a C{kCFSocket...} constant to an index into the read/write
state list (C{_READ} or C{_WRITE}) (the 4th element of the value of
C{self._fdmap}).
@param flag: C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack}
@return: C{_READ} or C{_WRITE}
)r r> r r? )r& r] r( r( r) r[
s
zCFReactor._flag2idxc C s t || jvr dS |dkr| jt | }n|}| j| \}}}}t|| d|| |< |t sK|t sM| jt |= | j|= t| j|t t
| dS dS dS )a
Unregister a file descriptor with the C{CFRunLoop}, or modify its state
so that it's listening for only one notification (read or write) as
opposed to both; used to implement C{removeReader} and C{removeWriter}.
@param fd: a file descriptor
@type fd: C{int}
@param descr: an L{IReadDescriptor} or L{IWriteDescriptor}
@param flag: C{kCFSocketWriteCallBack} C{kCFSocketReadCallBack}
Nr< F) rZ r0 r/ r r[ r> r? r r2 r r )r& rR r\ r] realfdrT r^ rK r( r( r)
_unwatchFD s
zCFReactor._unwatchFDc C | | |t dS )z7
Implement L{IReactorFDSet.addReader}.
N)ra r= r r& readerr( r( r) r9 7 zCFReactor.addReaderc C rd )z7
Implement L{IReactorFDSet.addWriter}.
N)ra r= r r& writerr( r( r) addWriter= rg zCFReactor.addWriterc C rd )z:
Implement L{IReactorFDSet.removeReader}.
N)rc r= r re r( r( r) removeReaderC rg zCFReactor.removeReaderc C rd )z:
Implement L{IReactorFDSet.removeWriter}.
N)rc r= r rh r( r( r) removeWriterI rg zCFReactor.removeWriterc C sH dd | j D }|t| j8 }|D ] }| | | | qt|S )z7
Implement L{IReactorFDSet.removeAll}.
c S s h | ]\}}}}|qS r( r( .0rT r^ r\ rK r( r( r) S s z&CFReactor.removeAll..)r/ valuessetr7 rk rl list)r& allDescdescr( r( r) removeAllO s
zCFReactor.removeAllc C dd | j D S )z8
Implement L{IReactorFDSet.getReaders}.
c S g | ] \}}}}|t r|qS r( )r> rm r( r( r)
^ z(CFReactor.getReaders..r/ rp r: r( r( r)
getReadersZ zCFReactor.getReadersc C rv )z8
Implement L{IReactorFDSet.getWriters}.
c S rw r( )r? rm r( r( r) rx d ry z(CFReactor.getWriters..rz r: r( r( r)
getWriters` r| zCFReactor.getWritersc C s t | |}| |S )aw
Override L{PosixReactorBase}'s implementation of L{IDelayedCall.reset}
so that it will immediately reschedule. Normally
C{_moveCallLaterSooner} depends on the fact that C{runUntilCurrent} is
always run before the mainloop goes back to sleep, so this forces it to
immediately recompute how long the loop needs to stay asleep.
)r _moveCallLaterSoonerr% )r& tpler' r( r( r) r~ f s z CFReactor._moveCallLaterSoonerFc C s$ d| _ z
| W d| _ dS d| _ w )z
Run the runner (C{CFRunLoopRun} or something that calls it), which runs
the run loop until C{crash()} is called.
TFN) _inCFLoopr1 r: r( r( r) mainLoopt s
zCFReactor.mainLoopc sx j dur
t j d _ }|rd}|dur:t | } fdd}tt|ddd|d } _ t j|t dS dS )aV
Schedule a call to C{self.runUntilCurrent}. This will cancel the
currently scheduled call if it is already scheduled.
@param force: Even if there are no timed calls, make sure that
C{runUntilCurrent} runs immediately (in a 0-seconds-from-now
C{CFRunLoopTimer}). This is necessary for calls which need to
trigger behavior of C{runUntilCurrent} other than running timed
calls, such as draining the thread call queue or calling C{crash()}
when the appropriate flags are set.
@type force: C{bool}
Ng c s d _ d S r. )_currentSimulatorrunUntilCurrentr% )cftimerextrar: r( r) simulate s z-CFReactor._scheduleSimulate..simulater ) r r timeoutr r r r r2 r )r& forcer fireDater cr( r: r) r% s
zCFReactor._scheduleSimulatec O s( t j| ||g|R i |}| |S )z6
Implement L{IReactorTime.callLater}.
)r callLaterr% )r& _seconds_fargskw delayedCallr( r( r) r s zCFReactor.callLaterc C s t | | d dS )z1
Implement L{IReactorCore.stop}.
TN)r stopr% r: r( r( r) r s
zCFReactor.stopc C s< | j }t| | jr| dS |r | d| j dS dS )z1
Implement L{IReactorCore.crash}
r N)_startedr crashr _stopNowr )r&
wasStartedr( r( r) r s
zCFReactor.crashc C s t | j dS )zJ
Immediately stop the CFRunLoop (which must be running!).
N)r r2 r: r( r( r) r s zCFReactor._stopNowr c C s | || j | dS )z
Emulate the behavior of C{iterate()} for things that want to call it,
by letting the loop run for a little while and then scheduling a timed
call to exit it.
N)r r r )r& delayr( r( r) iterate s zCFReactor.iterateNN)F)r )r* r+ r, r- r3 r; rV ra r[ rc r9 rj rk rl ru r{ r} r~ r r r r% r r r r r r( r( r( r) r R s2
&
B;
! c C s$ t | |d}ddlm} || |S )a6
Configure the twisted mainloop to be run inside CFRunLoop.
@param runLoop: the run loop to use.
@param runner: the function to call in order to actually invoke the main
loop. This will default to C{CFRunLoopRun} if not specified. However,
this is not an appropriate choice for GUI applications, as you need to
run NSApplicationMain (or something like it). For example, to run the
Twisted mainloop in a PyObjC application, your C{main.py} should look
something like this::
from PyObjCTools import AppHelper
from twisted.internet.cfreactor import install
install(runner=AppHelper.runEventLoop)
# initialize your application
reactor.run()
@return: The installed reactor.
@rtype: C{CFReactor}
)r4 r5 r )installReactor)r twisted.internet.mainr )r4 r5 r$ r r( r( r) r s r )+r- __all__rB zope.interfacer CFNetworkr r r r r r
r r r
r r CoreFoundationr r r r r r r r r r r twisted.internet.interfacesr twisted.internet.posixbaser r r twisted.pythonr r> r? rY r" r r r( r( r( r) s$ 44
|