EvgqEddlZddlZddlZddlZddlmZmZmZddlm Z ej dZ dZ e dZ eZGddZdZdS) N) async_to_synciscoroutinefunction sync_to_async)func_accepts_kwargszdjango.dispatchct|dr(t|jt|jfSt|S)N__func__)hasattrid__self__r)targets W/var/www/pixelcanvas.ch/venv/lib/python3.11/site-packages/django/dispatch/dispatcher.py_make_idr s?vz"":6?##R%8%899 f::cdeZdZdZddZddZddZddZd Zd Z d Z d Z d Z dZ dZddZdS)Signalz Base class for all signals Internal attributes: receivers { receiverkey (id) : weakref(receiver) } Fcg|_tj|_||_|rt jni|_d|_dS)z& Create a new signal. FN) receivers threadingLocklock use_cachingweakrefWeakKeyDictionarysender_receivers_cache_dead_receivers)selfrs r __init__zSignal.__init__#sPN$$ & FQ&Xg&?&A&A&AVX#$rNTc ddlm}|jrC|jrz!Signal.connect..ss.MM{uau *MMMMMMrN) django.confr configuredDEBUGcallable TypeErrorr ValueErrorrrrrefr WeakMethodr finalize_remove_receiverr_clear_dead_receiversanyrappendrclear) rreceiversenderweak dispatch_uidris_asyncr.receiver_objectr&s @r connectzSignal.connect2sD )(((((   8> H%% F DEEE&x00  P  @&(8(89JJ"8,,hv.>.>?J&x00  E+C&Ox,, 4:1N1N 4("*"3s8}}H  _d.C D D D Y 0 0  & & ( ( (MMMMdnMMMMM H%%z8X&FGGG  ' - - / / /  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0sA+E::E>E>c|r|t|f}nt|t|f}d}|j5|tt |jD]#}|j|^}}||kr d}|j|=n$|jdddn #1swxYwY|S)a Disconnect receiver from sender for signal. If weak references are used, disconnect need not be called. The receiver will be removed from dispatch automatically. Arguments: receiver The registered receiver to disconnect. May be none if dispatch_uid is specified. sender The registered sender to disconnect dispatch_uid the unique identifier of the receiver to disconnect FTN)rrr2rangelenrrr5) rr6r7r9r& disconnectedindexr$r%s r disconnectzSignal.disconnectws#&  @&(8(89JJ"8,,hv.>.>?J Y 0 0  & & ( ( (s4>2233   N51 J&&#'Lu-E'  ' - - / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0sA3B;;B?B?cn||\}}t|pt|Sr!)_live_receiversbool)rr7sync_receiversasync_receiverss r has_listenerszSignal.has_listenerss5*.*>*>v*F*F'N##.asend..sN$!EVEEuEErasynciogatherzip)async_responsesrGrPrr7s r asendzSignal.send..asendss(/(7)###### ?O<<*>v*F*F'& 3 3HxDtFDDeDDH   h1 2 2 2 2  5 = = = = = = = =   1]51133 4 4 4rcKjr!jturgS\}rt fd}nd}t j|t jfd|Dd{V\}}|t|||S)a~ Send signal from sender to all connected receivers in async mode. All sync receivers will be wrapped by sync_to_async() If any receiver raises an error, the error propagates back through send, terminating the dispatch loop. So it's possible that all receivers won't be called if an error is raised. If any receivers are synchronous, they are grouped and called behind a sync_to_async() adaption before executing any asynchronous receivers. If any receivers are asynchronous, they are grouped and executed concurrently with asyncio.gather(). Arguments: sender The sender of the signal. Either a specific object or None. named Named arguments which will be passed to receivers. Return a list of tuple pairs [(receiver, response), ...]. cZg}D]$}|dd}|||f%|SNrJr")r4)rZr6r[rPrr7rFs r sync_sendzSignal.asend..sync_sendsU .;;H'xLtFLLeLLH$$h%9::::  rc KgSr!r"r"rr r`zSignal.asend..sync_send  rc3.K|]}|ddVdSrNr"rOs r r'zSignal.asend..sN HADAA5AArN rrrWrXrDrrRrSrYrT)rr7rPrGr`rZrUrFs``` @r rVz Signal.asends<4 *..v66,FFI*.*>*>v*F*F'    ! ! ! ! ! ! !] ! !   ,3> IKK N$3 , , & & & & & & " ? _o>>???rcLtd|j||dS)Nz-Error calling %s in Signal.send_robust() (%s))exc_info)loggererror __qualname__)rr6errs r _log_robust_failurezSignal._log_robust_failures6 ;  !       rc  jr!jturgSg}\} |D]i} |dd}|||f&#t $r7}|||||fYd}~bd}~wwxYw r7fd fd}|t||S)a3 Send signal from sender to all connected receivers catching errors. If any receivers are asynchronous, they are called after all the synchronous receivers via a single call to async_to_sync(). They are also executed concurrently with asyncio.gather(). Arguments: sender The sender of the signal. Can be any Python object (normally one registered with a connect if you actually want something to occur). named Named arguments which will be passed to receivers. Return a list of tuple pairs [(receiver, response), ... ]. If any receiver raises an error (specifically any subclass of Exception), return the error instance as the result for that receiver. rJNcK |ddd{V}n/#t$r"}|||cYd}~Sd}~wwxYw|Sr_ Exceptionrkr6r[rjrPrr7s r asend_and_wrap_exceptionz4Signal.send_robust..asend_and_wrap_exception:s%-X%RT&%R%RE%R%RRRRRRRHH ,,Xs;;;JJJJJJ  A>AAchKtjfdDd{V}t|S)Nc3.K|]}|VdSr!r"r#r6rqs r r'z4Signal.send_robust..asend..DsB$10::rrQ)rUrqrGs r rVz!Signal.send_robust..asendBsi(/(7)###### ?O<<*>v*F*F'& 7 7H 7#8H4HH%HH   (H!56666  2 2 2((3777  (C11111111 2  5        = = = = = =   1]51133 4 4 4s A22 B3<-B..B3cKjr!jturgS\}rt fd}nd}fdt j|t jfd|Dd{V\}}|t|||S)at Send signal from sender to all connected receivers catching errors. If any receivers are synchronous, they are grouped and called behind a sync_to_async() adaption before executing any asynchronous receivers. If any receivers are asynchronous, they are grouped and executed concurrently with asyncio.gather. Arguments: sender The sender of the signal. Can be any Python object (normally one registered with a connect if you actually want something to occur). named Named arguments which will be passed to receivers. Return a list of tuple pairs [(receiver, response), ... ]. If any receiver raises an error (specifically any subclass of Exception), return the error instance as the result for that receiver. cg}D]i} |dd}|||f&#t$r7}|||||fYd}~bd}~wwxYw|Sr_)r4rork)rZr6r[rjrPrr7rFs r r`z&Signal.asend_robust..sync_sendss .??H?#+8#P4#P#P%#P#P "(((H)=>>>> %:::003???!(((C99999999: ! s , A--A((A-c KgSr!r"r"rr r`z&Signal.asend_robust..sync_sendrbrcK |ddd{V}n/#t$r"}|||cYd}~Sd}~wwxYw|Sr_rnrps r rqz5Signal.asend_robust..asend_and_wrap_exceptions !)!Nf!N!N!N!NNNNNNN   ((3777  Orrc3.K|]}|VdSr!r"rus r r'z&Signal.asend_robust..s/UU**844UUUUUUrNrd) rr7rPrGr`rZrUrqrFs ``` @@r asend_robustzSignal.asend_robustNsI4 *..v66,FFI+/*>*>v*F*F'    ! ! ! ! ! ! !] ! !          ,3> IKK NUUUU_UUU , , & & & & & & " ? _o>>???rcR|jrd|_d|jD|_dSdS)NFcrg|]4}t|dtjr|d2|5S)) isinstancer ReferenceType)r#rs r z0Signal._clear_dead_receivers..sL"1Q4)>??EIAaDFFNDRNNr)rr)rs r r2zSignal._clear_dead_receiverssE   #(D DNNN  rcd}|jr.|js'|j|}|turggfS||j5|t|}g}|jD]1\\}}}}|tks||kr| ||f2|jr|st|j|<n ||j|<dddn #1swxYwYg}g} |D]\}}t|tj r:|}|-|r| |C| |Y|r| |q| ||| fS)z Filter sequence of receivers to get resolved, live receivers. This checks for weak references and resolves them, then returning only live receivers. N)rrrrWrXrr2rrNONE_IDr4rrr) rr7r senderkey _receiverkey r_senderkeyr6r:non_weak_sync_receiversnon_weak_async_receiverss r rDzSignal._live_receiverss"   D$8 377??IL((2v   H H**,,,$V,,  GK~??C/\;8"g-- 1I1I!(((H)=>>>#H$H>J3F;;?H3F; H H H H H H H H H H H H H H H#%#% "+ = = Hh(G$9:: =#8::'A077AAAA/66x@@@=,33H====+228<<<<&(@@@sBCCCcd|_dS)NT)r)rr6s r r1zSignal._remove_receivers $r)F)NTN)NNNr!)__name__ __module__ri__doc__rr<rBrHr\rVrkrvr|r2rDr1r"rr rrs % % % %C0C0C0C0J""""H====,,,\888t   ===~FFFP,A,A,A\$$$$$$rrc fd}|S)a~ A decorator for connecting receivers to signals. Used by passing in the signal (or list of signals) and keyword arguments to connect:: @receiver(post_save, sender=MyModel) def signal_receiver(sender, **kwargs): ... @receiver([post_save, post_delete], sender=MyModel) def signals_receiver(sender, **kwargs): ... ctttfrD]}|j|finj|fi|Sr!)rlisttupler<)funcskwargsrKs r _decoratorzreceiver.._decoratorsk ftUm , , + * * $))&)))) * FN4 * *6 * * * rr")rKrrs`` r r6r6s* r)rRloggingrr asgiref.syncrrrdjango.utils.inspectr getLoggerrgrrobjectrXrr6r"rr rsJJJJJJJJJJ444444  , - - (4..vxx |$|$|$|$|$|$|$|$~ r