hqESSKrSSKrSSKrSSKrSSKJrJrJr SSKJ r \R"S5r Sr \ "S5r \"5r"SS5rSrg) N) async_to_synciscoroutinefunction sync_to_async)func_accepts_kwargszdjango.dispatchc[US5(a*[UR5[UR54$[U5$)N__func__)hasattrid__self__r)targets L/var/www/html/env/lib/python3.13/site-packages/django/dispatch/dispatcher.py_make_idr s6vz""6??#R%899 f:ct\rSrSrSrSSjrSSjrSSjrSSjrSr S r S r S r S r S rSrSSjrSrg)Signalzr Base class for all signals Internal attributes: receivers { receiverkey (id) : weakref(receiver) } c/Ul[R"5UlXlU(a[ R "5O0UlSUlg)z Create a new signal. FN) receivers threadingLocklock use_cachingweakrefWeakKeyDictionarysender_receivers_cache_dead_receivers)selfrs r __init__Signal.__init__#sANN$ & FQg&?&?&AVX#$rNcN^ SSKJn UR(aGUR(a6[ U5(d [ S5e[ U5(d [S5eU(aU[U54m O[U5[U54m [U5nU(ax[RnUn[US5(a-[US5(a[RnURnU"U5n[R"XR 5 UR" UR%5 ['U 4SjUR(55(dUR(R+T X45 UR,R/5 SSS5 g!,(df  g=f) aF Connect receiver to sender for signal. Arguments: receiver A function or an instance method which is to receive signals. Receivers must be hashable objects. Receivers can be asynchronous. If weak is True, then receiver must be weak referenceable. Receivers must be able to accept keyword arguments. If a receiver is connected with a dispatch_uid argument, it will not be added if another receiver was already connected with that dispatch_uid. sender The sender to which the receiver should respond. Must either be a Python object, or None to receive events from any sender. weak Whether to use weak references to the receiver. By default, the module will attempt to use weak references to the receiver objects. If this parameter is false, then strong references will be used. dispatch_uid An identifier used to uniquely identify a particular instance of a receiver. This will usually be a string, though it may be anything hashable. r)settingsz"Signal receivers must be callable.z:Signal receivers must accept keyword arguments (**kwargs).r rc34># UH un o!T:Hv M g7fN).0r_key_ lookup_keys r !Signal.connect..ssMn{ua *nN) django.confr! configuredDEBUGcallable TypeErrorr ValueErrorrrrrefr WeakMethodr finalize_remove_receiverr_clear_dead_receiversanyrappendrclear) rreceiversenderweak dispatch_uidr!is_asyncr2receiver_objectr(s @r connectSignal.connect2s6D )   8>>H%% DEE&x00 P &(89J"8,hv.>?J&x0 ++C&Ox,,:1N1N(("*"3"38}H   _.C.C D YY  & & (MdnnMMM%%z8&FG  ' ' - - / YYs !A,F F$cU(aU[U54nO[U5[U54nSnUR UR5 [[ UR 55H)nUR UtpxXt:XdMSnUR U O UR R5 SSS5 U$!,(df  U$=f)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)rrr6rangelenrrr9) rr:r;r=r( disconnectedindexr&r's r disconnectSignal.disconnectws& &(89J"8,hv.>?J YY  & & (s4>>23 NN51 &#'Lu- 4  ' ' - - /YsAB:-B:: C cbURU5up#[U5=(d [U5$r#)_live_receiversbool)rr;sync_receiversasync_receiverss r has_listenersSignal.has_listenerss**.*>*>v*F'N## [R"UUU4SjT56IShvN n[TU5$N7f)Nc3:># UHnU"STTS.TD6v M g7frQNr$r$r%r:namedrr;s r r)-Signal.send..asend..s'(7H!EVEuE(7asynciogatherzip)async_responsesrMrWrr;s r asendSignal.send..asends:(/(7)# ?O<< #s #979r$)rrget NO_RECEIVERSrJr8extendr) rr;rW responsesrLr:responser_rMs ``` @r send Signal.sends.**..v6,FI *.*>*>v*F'&HDtFDeDH   h1 2'  = =   ]513 4rc^^^^# TR(a"TRRT5[La/$TR T5umnT(a[ UUUU4Sj5nOSn[ R"U"5[ R"UUU4SjU565IShvN upVUR[X655 U$N"7f)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), ...]. cX>/nTH nU"STTS.TD6nURX45 M" U$NrQr$)r8)rdr:rerWrr;rLs r sync_sendSignal.asend..sync_sends? .H'LtFLeLH$$h%9:!/! rc# /$7fr#r$r$rr rkrl  c3:># UHnU"STTS.TD6v M g7frUr$rVs r r)Signal.asend..s'$3ADA5A$3rYN rrrarbrJrr[r\rcr])rr;rWrMrkrdr^rLs``` @r r_ Signal.asends4**..v6,FI*.*>*>v*F'   ! ! ,3>> K NN$3 , & "  _>?& sB#C)C *#CcD[RSURUUS9 g)Nz-Error calling %s in Signal.send_robust() (%s))exc_info)loggererror __qualname__)rr:errs r _log_robust_failureSignal._log_robust_failures% ;  ! !   rc ^^^^ ^ TR(a"TRRT5[La/$/nTR T5unm UH!nU"STTS.TD6nUR XV45 M# T (a.UUU4Sjm U U 4SjnUR[U5"55 U$![ a.nTRXW5 UR XW45 SnAMSnAff=f)a 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. rQNc># U"STTS.TD6IShvN nU$N![anTRX5 UsSnA$SnAff=f7frj Exceptionrzr:reryrWrr;s r asend_and_wrap_exception4Signal.send_robust..asend_and_wrap_exception:sQ%-%RT&%RE%RRH  S ,,X;J8AA A>AAAAcr># [R"U4SjT56IShvN n[TU5$N7f)Nc34># UH nT"U5v M g7fr#r$r%r:rs r r)4Signal.send_robust..asend..Ds (7H1::(7r+rZ)r^rrMs r r_!Signal.send_robust..asendBs:(/(7)# ?O<< #s !757r$) rrrarbrJr8rrzrcr) rr;rWrdrLr:reryr_rrMs ``` @@r send_robustSignal.send_robusts0**..v6,FI *.*>*>v*F'&H 7#H4H%H   (!56'   =   ]513 43 2((7  (11 2s B// C'9#C""C'c^^^^^# TR(a"TRRT5[La/$TR T5umnT(a[ UUUU4Sj5nOSnUUU4Sjm[ R"U"5[ R"U4SjU565IShvN upVUR[X655 U$N"7f)a 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. c>/nTH!nU"STTS.TD6nURX45 M# U$![a.nTRX5 URX45 SnAMZSnAff=frj)r8rrz)rdr:reryrWrr;rLs r rk&Signal.asend_robust..sync_sendssy .H?#+#P4#P%#P "((()=>!/! %:00?!(((99:s - A%#A  A%c# /$7fr#r$r$rr rkrrnroc># U"STTS.TD6IShvN nU$N![anTRX5 UsSnA$SnAff=f7frjr~rs r r5Signal.asend_robust..asend_and_wrap_exceptionsQ !)!Nf!N!NNO O ((7  rc34># UH nT"U5v M g7fr#r$rs r r)&Signal.asend_robust..sU_*844_r+Nrr) rr;rWrMrkrdr^rrLs ``` @@r asend_robustSignal.asend_robustNs4**..v6,FI+/*>*>v*F'   ! !  ,3>> K NNU_U , & " _>?& sB)C0C1#CcUR(aYSUlURVs/sH4n[US[R5(a US"5cM2UPM6 snUlggs snf)NF)rr isinstancer ReferenceType)rrs r r6Signal._clear_dead_receiverssa   #(D 'A"1Q4)>)>??AaDF'DN s 1A,A,c:SnUR(a9UR(d(URRU5nU[La//4$UcUR  UR 5 [U5n/nURH+uupEpgU[:XdXS:XdMURXg45 M- UR(a)U(d[URU'OX RU'SSS5 /n/n UHupg[U[R5(a9U"5nUb-U(aU RU5 MHURU5 M[M]U(aU RU5 MwURU5 M X4$!,(df  N=f)z Filter sequence of receivers to get resolved, live receivers. This checks for weak references and resolves them, then returning only live receivers. N)rrrrarbrr6rrNONE_IDr8rrr) rr;r senderkey _receiverkey r_senderkeyr:r>non_weak_sync_receiversnon_weak_async_receiverss r rJSignal._live_receiverssh   D$8$83377?IL(2v  **,$V,  GK~~C/\"g-1I!((()=>HV##$>J33F;?H33F;#%#% "+ H(G$9$9::#:'077A/66x@ ( ,33H=+228<#,'@@;s?F AF  FcSUlg)NT)r)rr:s r r5Signal._remove_receivers  $r)rrrrr)F)NTN)NNNr#)__name__ __module__rx__firstlineno____doc__rr@rGrNrfr_rzrrr6rJr5__static_attributes__r$rr rrsM %C0J"H=,\8t =~FP,A\$rrc ^^UU4SjnU$)aZ 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): ... c>[T[[45(aTHnUR"U40TD6 M U$TR"U40TD6 U$r#)rlisttupler@)funcskwargsrRs r _decoratorreceiver.._decoratorsN ftUm , , $)&)  NN4 *6 * rr$)rRrrs`` r r:r:s r)r[loggingrr asgiref.syncrrrdjango.utils.inspectr getLoggerrvrrobjectrbrr:r$rr rsVJJ4   , - 4.x |$|$~ r