o &hj@sdZddlZddlZddlZddlZddlZddlmZmZm Z m Z ddl m Z m Z mZmZmZmZmZddlmZmZddlmZmZddlmZejd kr\dd lmZmZmZmZn ejd kridd lmZmZgd Z edZ!eZ"dZ#eZ$eZ%eZ&eZ'eZ(e&Z)eZ*eZ+e de+eZ,eZ-eZ.e de-e.e$eeZ/eZ0eZ1e1Z2GdddeZ3ee!dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZe2e!j?_@ge!j?_Ae'e!jB_@e'ge!jB_Ae'e!jC_@e'ge!jC_Ade!jD_@e(e*e)ge!jD_Ade!jE_@e(e+e)ge!jE_Ae(e!jF_@ge!jF_Ae(e!jG_@ge!jG_Ade!jH_@e(e*e)ge!jH_Ade!jI_@e(e+e)ge!jI_Ade!jJ_@ge!jJ_Ade!jK_@e(ge!jK_Ae+e!jL_@e"e2e1e%ee,e e3ge!jL_Ae*e!jM_@e"e-ege!jM_Ae-e!jN_@e"e0e%e/e e>ge!jN_Ade!jO_@e-e%ge!jO_Ade!jP_@e-e%ge!jP_Ade!jQ_@e-ge!jQ_Ade!jR_@e-e%ge!jR_AGdddejSZTGdddejUZVddZWGdd d e jXZYejd krGd!d"d"eZZejd krd#d$Z[neYZ[Gd%d&d&Z\Gd'd(d(Z]Gd)d*d*Z^dS)+z,PEP 3156 event loop based on CoreFoundation.N) coroutineseventstasks unix_events) CFUNCTYPEPOINTER Structurec_doublec_intc_ulongc_void_p) ObjCClass objc_const) load_libraryobjc_id)CFIndex)AbstractEventLoopPolicyDefaultEventLoopPolicySafeChildWatcherset_event_loop_policy)r)rr)EventLoopPolicyCocoaLifecycleRubiconEventLoop iOSLifecycleZCoreFoundationc@@eZdZdeeefdefdedefdedefdefgZdS)CFRunLoopTimerContextcopyDescriptioninforeleaseNretainversion__name__ __module__ __qualname__r CFStringRefr rZ_fields_r+r+m/Users/merlin/projects/employee-monitoring-system/venv/lib/python3.10/site-packages/rubicon/objc/eventloop.pyr Q   r kCFRunLoopCommonModesr NSRunLoopc@r)CFSocketContextr!r"r#Nr$r%r&r+r+r+r,r3qr-r3cs0eZdZddZfddZfddZZS) CFTimerHandlecsfdd}t|S)NcsjjdSN)_loop_timersdiscard)Zcftimerextraargscallbackselfr+r,cf_timer_callbacksz;CFTimerHandle._cf_timer_callback..cf_timer_callback)CFRunLoopTimerCallBack)r=r<r;r>r+r:r,_cf_timer_callbacksz CFTimerHandle._cf_timer_callbackc sjtt||||d|||_|jj|t t |j ddd|j d|_ t|jj|j tdS)Nr)super__init__libcfCFAbsoluteTimeGetCurrentr@_timeoutr6r7addCFRunLoopTimerCreatekCFAllocatorDefault_when _callback_timerCFRunLoopAddTimer _cfrunloopr.)r=looptimeoutr<r; __class__r+r,rBs(   zCFTimerHandle.__init__cs0tt|jj|jt|jj |dS)zCancel the Timer handle.N) rAcancelrCCFRunLoopRemoveTimerr6rMrKr.r7r8r=rPr+r,rRs  zCFTimerHandle.cancel)r'r(r)r@rBrR __classcell__r+r+rPr,r4s r4csPeZdZddZfddZddZddZd d Zd d Zfd dZ Z S)CFSocketHandlecCsx|j|jjvrt|jj|jtd|_dS|tkr#|j r#|j \}}n|t kr0|j r0|j \}}nd}|r:||dSdSr5) _fdr6_socketsrCCFRunLoopRemoveSourcerM_srcr.kCFSocketReadCallBack_readerkCFSocketWriteCallBack_writer)r=ZcfSocketZ callbackTypeZignoredAddressZ ignoredDatacontextr<r;r+r+r,_cf_socket_callbacks    z"CFSocketHandle._cf_socket_callbackcstt|jd|||jj|<d|_d|_||_t t |jt t BtB|jd|_t |jttBt t |jd|_t |jj|jtt |jt t BtBdS)zRegister a file descriptor with the CFRunLoop, or modify its state so that it's listening for both notifications (read and write) rather than just one; used to implement add_reader and add_writer.Nr)rArBCFSocketCallbackr`r6rXr\r^rWrCCFSocketCreateWithNativerHr[r]kCFSocketConnectCallBackrJ _cf_socketCFSocketSetSocketFlags*kCFSocketAutomaticallyReenableReadCallBack+kCFSocketAutomaticallyReenableWriteCallBackCFSocketCreateRunLoopSourcerZCFRunLoopAddSourcerMr.CFSocketDisableCallBacks)r=rNfdrPr+r,rBs8     zCFSocketHandle.__init__cCt|jt||f|_dS)z/Add a callback for read activity on the socket.N)rCCFSocketEnableCallBacksrdr[r\r=r<r;r+r+r, enable_read7zCFSocketHandle.enable_readcC t|jtd|_|dS)z4Remove the callback for read activity on the socket.N)rCrjrdr[r\rRrTr+r+r, disable_read< zCFSocketHandle.disable_readcCrl)z0Add a callback for write activity on the socket.N)rCrmrdr]r^rnr+r+r, enable_writeBrpzCFSocketHandle.enable_writecCrq)z5Remove the callback for write activity on the socket.N)rCrjrdr]r^rRrTr+r+r, disable_writeGrszCFSocketHandle.disable_writecs`|jdur*|jdur,|jr.t|jj|j=t |jj |jt t |j dSdSdSdS)a1(Potentially) cancel the socket handle. A socket handle can have both reader and writer components; a call to cancel a socket handle will only be successful if *both* the reader and writer component have been disabled. If either is still active, cancel() will be a no-op. N)r\r^rZrArRr6rXrWrCrYrMr.CFSocketInvalidaterdrTrPr+r,rRMs    zCFSocketHandle.cancel) r'r(r)r`rBrorrrtrurRrUr+r+rPr,rVs 'rVcs"durtfdd}|S)Ncsjg|RdSr5)run)r;r<r_r+r,rJbsz#context_callback.._callback) contextvars copy_context)r_r<rJr+rxr,context_callback^sr{cseZdZd3fdd ZfddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ ddZddZddZd3ddZd3d d!Zdd"d#d$ZeZdd"d%d&Zdd"d'd(Zd)d*Zfd+d,Zfd-d.Zd/d0Zd1d2ZZS)4 CFEventLoopNcs>||_tt|_d|_t|_i|_i|_ t dS)NF) _lifecyclerCCFRetainCFRunLoopGetCurrentrM_runningsetr7_accept_futuresrXrArBr=Z lifecyclerPr+r,rBiszCFEventLoop.__init__cst|jtdSr5)rC CFReleaserMrA__del__rTrPr+r,rts zCFEventLoop.__del__cGHz|j|}Wntyt||d}||j|<Ynw|||dSN)rNrk)rXKeyErrorrVror=rkr<r;handler+r+r, _add_readerx  zCFEventLoop._add_readercG|j||g|RdS)zAdd a reader callback. Method is a direct call through to _add_reader to reflect an internal implementation detail added in Python3.5. N)rr=rkr<r;r+r+r, add_readerzCFEventLoop.add_readercC*z |j|WdStyYdSwNTF)rXrrrr=rkr+r+r,_remove_reader  zCFEventLoop._remove_readercC||dS)zRemove a reader callback. Method is a direct call through to _remove_reader to reflect an internal implementation detail added in Python3.5. N)rrr+r+r, remove_readerzCFEventLoop.remove_readercGrr)rXrrVrtrr+r+r, _add_writerrzCFEventLoop._add_writercGr)zAdd a writer callback. Method is a direct call through to _add_writer to reflect an internal implementation detail added in Python3.5. N)rrr+r+r, add_writerrzCFEventLoop.add_writercCrr)rXrurrr+r+r,_remove_writerrzCFEventLoop._remove_writercCr)zRemove a writer callback. Method is a direct call through to _remove_writer to reflect an internal implementation detail added in Python3.5. N)rrr+r+r, remove_writerrzCFEventLoop.remove_writercCs(t|s t|rtd|ddS)z7Check whether the given callback is a coroutine or not.zcoroutines cannot be used with z()N)r iscoroutineinspectiscoroutinefunction TypeError)r=r<namer+r+r,_check_not_coroutinesz CFEventLoop._check_not_coroutinecCs|jS)z*Returns True if the event loop is running.)rrTr+r+r, is_runningszCFEventLoop.is_runningc Cs|}|sttdrtrtd|s"d|_ttdr"t|z|jW|s:d|_ttdr.stop)rNz+Event loop stopped before Future completed.Nr+)r ensure_futureadd_done_callback run_foreverremove_done_callbackdonerresult)r=futurekwrr+rTr,run_until_completes  zCFEventLoop.run_until_completecCsP|js||r |nt|j|rtdz |W|dS|w)zRun until stop() is called.\Recursively calling run_forever is forbidden. To recursively run the event loop, call run().N)r}_set_lifecycle CFLifecyclerMrrrwrrr+r+r,rs zCFEventLoop.run_forevercCsZ|js||r |nt|j|rtdd|_ttdr$t || |jj dS)aA non-blocking version of :meth:`run_forever`. This may seem like nonsense; however, an iOS app is not expected to invoke a blocking "main event loop" method. As a result, we need to be able to *start* Python event loop handling, but then return control to the main app to start the actual event loop. The implementation is effectively all the parts of a call to :meth:`run_forever()`, but without any of the shutdown/cleanup logic. rTrN) r}rrrMrrrrrr call_soonrrr+r+r,run_forever_cooperatively s   z%CFEventLoop.run_forever_cooperatively)r_cGs"||dt|dt|||dS)aTArrange for a callback to be called as soon as possible. This operates as a FIFO queue: callbacks are called in the order in which they are registered. Each callback will be called exactly once. Any positional arguments after the callback will be passed to the callback when it is called. rrrNrOr<r;rr4r{)r=r<r_r;r+r+r,r+s zCFEventLoop.call_sooncGs"||dt||t|||dS)a8Arrange for a callback to be called at a given time. Return a Handle: an opaque object with a cancel() method that can be used to cancel the call. The delay can be an int or float, expressed in seconds. It is always relative to the current time. Each callback will be called exactly once. If two callbacks are scheduled for exactly the same time, it undefined which will be called first. Any positional arguments after the callback will be passed to the callback when it is called. call_laterrr)r=delayr<r_r;r+r+r,r@s zCFEventLoop.call_latercGs*||dt|||t|||dS)z|Like call_later(), but uses an absolute time. Absolute time corresponds to the event loop's time() method. call_atr)rr4timer{)r=whenr<r_r;r+r+r,rYs  zCFEventLoop.call_atcCstS)zReturn the time according to the event loop's clock. This is a float expressed in seconds since an epoch, but the epoch, precision, accuracy and drift are unspecified and may differ per event loop. )rCrDrTr+r+r,rgszCFEventLoop.timecst|jdS)zStop running the event loop. Every callback already scheduled will still run. This simply informs run_forever to stop looping after a complete iteration. N)rArr}rTrPr+r,ros zCFEventLoop.stopcsJ|jr|j}||js|jr|j}||jstdS)zClose the event loop. This clears the queues and shuts down the executor, but does not wait for the executor to finish. The event loop must not be running. N)rpoprRr7rAclose)r=rhandlerrPr+r,rxs  zCFEventLoop.closecCsB|jdur td|rtd||_tjdkr||j_dSdS)zs$                 /g  @ [