ztfhUdZddlmZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z ddl mZmZmZddlmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&d d l'm(Z(d d l)m*Z*d d l+m,Z,d d l-m.Z.m/Z/m0Z0m1Z1m2Z2er'd dl3m4Z4d dl-m5Z5eee6ge6fZ7ee6e6ge6fZ8e!e7e8fZ9gdZ:e;Z<e deZ=ej|Z?edZ@eAe@jZCdZDdeEd<GddZFGddZGeZHe*dGddZIGdd ZJGd!d"ZKd4d#ZLeed$ej%ed&ej%gZOed'd5d(ZPd6d)ZQd7d*ZR d8 d9d,ZS d: d;d-ZTdd1ZXd+eEd2<d?d3ZYy)@a+ The main Signal class and SignalInstance class. A note on the "reemission" parameter in Signal and SignalInstances. This controls the behavior of the signal when a callback emits the signal. Since it can be a little confusing, take the following example of a Signal that emits an integer. We'll connect three callbacks to it, two of which re-emit the same signal with a different value: ```python from psygnal import SignalInstance # a signal that emits an integer sig = SignalInstance((int,), reemission="...") def cb1(value: int) -> None: print(f"calling cb1 with: {value}") if value == 1: # cb1 ALSO triggers an emission of the value 2 sig.emit(2) def cb2(value: int) -> None: print(f"calling cb2 with: {value}") if value == 2: # cb2 ALSO triggers an emission of the value 3 sig.emit(3) def cb3(value: int) -> None: print(f"calling cb3 with: {value}") sig.connect(cb1) sig.connect(cb2) sig.connect(cb3) sig.emit(1) ``` with `reemission="queued"` above: you see a breadth-first pattern: ALL callbacks are called with the first emitted value, before ANY of them are called with the second emitted value (emitted by the first connected callback cb1) ``` calling cb1 with: 1 calling cb2 with: 1 calling cb3 with: 1 calling cb1 with: 2 calling cb2 with: 2 calling cb3 with: 2 calling cb1 with: 3 calling cb2 with: 3 calling cb3 with: 3 ``` with `reemission='immediate'` signals emitted by callbacks are immediately processed by all callbacks in a deeper level, before returning back to the original loop level to call the remaining callbacks with the original value. ``` calling cb1 with: 1 calling cb1 with: 2 calling cb2 with: 2 calling cb1 with: 3 calling cb2 with: 3 calling cb3 with: 3 calling cb3 with: 2 calling cb2 with: 1 calling cb3 with: 1 ``` with `reemission='latest'`, just as with 'immediate', signals emitted by callbacks are immediately processed by all callbacks in a deeper level. But in this case, the remaining callbacks in the current level are never called with the original value. ``` calling cb1 with: 1 calling cb1 with: 2 calling cb2 with: 2 calling cb1 with: 3 calling cb2 with: 3 calling cb3 with: 3 # cb2 is never called with 1 # cb3 is never called with 1 or 2 ``` The real-world scenario in which this usually arises is an EventedModel or dataclass. Evented models emit signals on `setattr`: ```python class MyModel(EventedModel): x: int = 1 m = MyModel(x=1) print("starting value", m.x) @m.events.x.connect def ensure_at_least_20(val: int): print("trying to set to", val) m.x = max(val, 20) m.x = 5 print("ending value", m.x) ``` ``` starting value 1 trying to set to 5 trying to set to 20 ending value 20 ``` With EventedModel.__setattr__, you can easily end up with some complicated recursive behavior if you connect an on-change callback that also sets the value of the model. In this case `reemission='latest'` is probably the most appropriate, as it will prevent the callback from being called with the original (now-stale) value. But one can conceive of other scenarios where `reemission='immediate'` or `reemission='queued'` might be more appropriate. Qt's default behavior, for example, is similar to `immediate`, but can also be configured to be like `queued` by changing the connection type (in that case, depending on threading). ) annotationsN)deque)contextmanagersuppress) lru_cachepartialreduce) Parameter Signatureisclass) TYPE_CHECKINGAnyCallableClassVarContextManagerFinalIterableIteratorLiteralNoReturnTypeTypeVarUnioncastget_args get_originget_type_hintsoverload) EmitLoopError) mypyc_attr)QueuedCallback)StrongFunction WeakCallback WeakSetattr WeakSetitem weak_callback EmissionInfo)RefErrorChoice)SignalSignalInstance _compiledF)bound) immediatequeued latest-onlyr0 ReemissionValDEFAULT_REEMISSIONc`eZdZUdZdZded<dZded<dZded<ed d Z ed d Z y )ReemissionModez%Enumeration of reemission strategies.r0r IMMEDIATEr1QUEUEDr2LATESTct|j}|tjvr2t ddj tjd||S)Nz)Invalid reemission value. Must be one of z, z. Not )strlowerr6_members ValueErrorjoin)values Y/var/www/html/software/conda/envs/higlass/lib/python3.12/site-packages/psygnal/_signal.pyvalidatezReemissionMode.validates`E   " //1 1;99^44678uiI  ctSN)VALID_REEMISSIONrCrAr=zReemissionMode._memberssrCN)r@r;returnr;)rHzset[str]) __name__ __module__ __qualname____doc__r7__annotations__r8r9 staticmethodrBr=rGrCrAr6r6sI/"Iu"FE!FE!  rCr6ceZdZUdZdZded<dddded dd Zedd Z dd Z e ddd Z e d dd Z d ddZ ddZ d ddZeeddZeddZeddZy) r+a[ Declares a signal emitter on a class. This is class implements the [descriptor protocol](https://docs.python.org/3/howto/descriptor.html#descriptorhowto) and is designed to be used as a class attribute, with the supported signature types provided in the constructor: ```python from psygnal import Signal class MyEmitter: changed = Signal(int) def receiver(arg: int): print("new value:", arg) emitter = MyEmitter() emitter.changed.connect(receiver) emitter.changed.emit(1) # prints 'new value: 1' ``` !!! note in the example above, `MyEmitter.changed` is an instance of `Signal`, and `emitter.changed` is an instance of `SignalInstance`. See the documentation on [`SignalInstance`][psygnal.SignalInstance] for details on how to connect to and/or emit a signal on an instance of an object that has a `Signal`. Parameters ---------- *types : Type[Any] | Signature A sequence of individual types, or a *single* [`inspect.Signature`][] object. description : str Optional descriptive text for the signal. (not used internally). name : str | None Optional name of the signal. If it is not specified then the name of the class attribute that is bound to the signal will be used. default None check_nargs_on_connect : bool Whether to check the number of positional args against `signature` when connecting a new callback. This can also be provided at connection time using `.connect(..., check_nargs=True)`. By default, `True`. check_types_on_connect : bool Whether to check the callback parameter types against `signature` when connecting a new callback. This can also be provided at connection time using `.connect(..., check_types=True)`. By default, `False`. reemission : Literal["immediate", "queued", "latest-only"] | None Determines the order and manner in which connected callbacks are invoked when a callback re-emits a signal. Default is `"immediate"`. * `"immediate"`: Signals emitted by callbacks are immediately processed in a deeper emission loop, before returning to process signals emitted at the current level (after all callbacks in the deeper level have been called). * `"queued"`: Signals emitted by callbacks are enqueued for emission after the current level of emission is complete. This ensures *all* connected callbacks are called with the first emitted value, before *any* of them are called with values emitted while calling callbacks. * `"latest-only"`: Signals emitted by callbacks are immediately processed in a deeper emission loop, and remaining callbacks in the current level are never called with the original value. NzClassVar[SignalInstance | None]_current_emitterTF) descriptionnamecheck_nargs_on_connectcheck_types_on_connect reemissionc4||_||_||_||_||_t |_i|_|rJt|dtr7|d|_ t|dkDrtjd|dddyyttd||_ y)NrrzdOnly a single argument is accepted when directly providing a `Signature`. These args were ignored:  stacklevelztuple[Type[Any], ...])_namerR_check_nargs_on_connect_check_types_on_connect _reemissionr,_signal_instance_class_signal_instance_cache isinstancer _signaturelenwarningswarn_build_signaturer)selfrRrSrTrUrVtypess rA__init__zSignal.__init__#s &'=$'=$%>rC)rhztype[Any] | SignaturerRr;rS str | NonerTboolrUrrVr3rHNonerHr )rq type[Any]rSr;rHrrE)rurrqtype[Any] | NonerHr+)rurrqrrHr,)rurrqrrHzSignal | SignalInstance)rurr~r,rHr)rurrSrrHr,)rr,rHzIterator[None])rHzSignalInstance | NonerHr)rIrJrKrLrPrMr4ripropertyrmrrrrvr}rz classmethodrrrrrGrCrAr+r+syBL9=5< '+',$6V%VV V !% V !% V"V V8 TT 7;$4  8<''$4' 'R V V.< V  V15    #-    ,,$$"??rCr+T)allow_interpreted_subclassesc eZdZUdZdZded<dZded<dZded<efddd de d  d5d Z e d6d Z e d7d Ze d8dZe d9dZd9dZedddddddd d:dZedddddddd d;dZ ddZd?dZd@dAdZefddd dBdZ d@ dCdZefddd dDdZ d@ dEdZ dFd ZdGdHd!ZdId"ZdJdKd#ZdLd$Z dMd%Z!ddd& dNd'Z"ddd& dNd(Z#dOd)Z$dPd*Z%dPd+Z&dPd,Z'dQdRd-Z(dPd.Z)dSd/Z*dPd0Z+defdTd1Z,def dUd2Z-dVd3Z.dWd4Z/y)Xr,aA signal instance (optionally) bound to an object. In most cases, users will not create a `SignalInstance` directly -- instead creating a [Signal][psygnal.Signal] class attribute. This object will be instantiated by the `Signal.__get__` method (i.e. the descriptor protocol), when a `Signal` instance is accessed from an *instance* of a class with `Signal` attribute. However, it is the `SignalInstance` that you will most often be interacting with when you access the name of a `Signal` on an instance -- so understanding the `SignalInstance` API is key to using psygnal. ```python class Emitter: signal = Signal() e = Emitter() # when accessed on an *instance* of Emitter, # the signal attribute will be a SignalInstance e.signal # This is what you will use to connect your callbacks e.signal.connect(some_callback) ``` Parameters ---------- signature : Signature | None The signature that this signal accepts and will emit, by default `Signature()`. instance : Any An object to which this signal is bound. Normally this will be provided by the `Signal.__get__` method (see above). However, an unbound `SignalInstance` may also be created directly. by default `None`. name : str | None An optional name for this signal. Normally this will be provided by the `Signal.__get__` method. by default `None` check_nargs_on_connect : bool Whether to check the number of positional args against `signature` when connecting a new callback. This can also be provided at connection time using `.connect(..., check_nargs=True)`. By default, `True`. check_types_on_connect : bool Whether to check the callback parameter types against `signature` when connecting a new callback. This can also be provided at connection time using `.connect(..., check_types=True)`. By default, `False`. reemission : Literal["immediate", "queued", "latest-only"] | None See docstring for [`Signal`][psygnal.Signal] for details. By default, `"immediate"`. Raises ------ TypeError If `signature` is neither an instance of `inspect.Signature`, or a `tuple` of types. Fr _is_blocked _is_pausedNz/ClassVar[Callable[[EmissionInfo], None] | None] _debug_hookTrct|ttfr t|}nt|ts t dt j||_||_ |j||_ g|_ ||_ ||_||_g|_d|_d|_t'j(|_t-|_d|_d|_||jt j4k(r|j6|_d|_ y|jt j:k(r|j<|_d|_ y|j>|_d|_ y)NzU`signature` must be either a sequence of types, or an instance of `inspect.Signature`Fr)!ralisttuplerfr rr6rBr^r[ _instance_ref _instance _args_queuerbr\r]_slotsrr threadingRLock_lockr _emit_queue_recursion_depth_max_recursion_depthr8_run_emit_loop_queued_run_emit_loop_innerr9_run_emit_loop_latest_only_run_emit_loop_immediate_priority_in_use)rgrmrurSrTrUrVs rArizSignalInstance.__init__s: i$ /()4IIy12  *22:> #'#5#5h#?(*#'=$'=$*, !& %__& ).%&)*!   ~44 4(,(B(BD %!&   !6!6 6(,(G(GD % !&)-(E(ED %!&rCcbdS tjS#t$rfdcYSwxYw)NcyrErGrGrCrAz.SignalInstance._instance_ref..(rCcSrErGrusrArz.SignalInstance._instance_ref...s8rC)rrefrrs`rArzSignalInstance._instance_ref%s8    $;;x( ( $# # $s ..c|jS)z-Signature supported by this `SignalInstance`.rkrls rArmzSignalInstance.signature0rnrCc"|jS)z(Object that emits this `SignalInstance`.)rrls rAruzSignalInstance.instance5s~~rCc"|jxsdS)zName of this `SignalInstance`.rQrprls rArSzSignalInstance.name:szzRrCc|jrd|jnd}|jd|jnd}dt|j||dS)z Return repr. rQz on <>)r[rutyperI)rgrSrus rA__repr__zSignalInstance.__repr__?sX%)ZZ4::.!R/3}}/HT$--*+b4:&&'vhZq99rC.)thread check_nargs check_typesuniquemax_args on_ref_errorprioritycyrErG)rgrrrrrrrs rAconnectzSignalInstance.connectEsrCcyrErG) rgslotrrrrrrrs rArzSignalInstance.connectRs rCrerc j j||f dfd } || S| |S)aConnect a callback (`slot`) to this signal. `slot` is compatible if: * it requires no more than the number of positional arguments emitted by this `SignalInstance`. (It *may* require less) * it has no *required* keyword arguments (keyword only arguments that have no default). * if `check_types` is `True`, the parameter types in the callback signature must match the signature of this `SignalInstance`. This method may be used as a decorator. ```python @signal.connect def my_function(): ... ``` !!!important If a signal is connected with `thread != None`, then it is up to the user to ensure that `psygnal.emit_queued` is called, or that one of the backend convenience functions is used (e.g. `psygnal.qt.start_emitting_from_queue`). Otherwise, callbacks that are connected to signals that are emitted from another thread will never be called. Parameters ---------- slot : Callable A callable to connect to this signal. If the callable accepts less arguments than the signature of this slot, then they will be discarded when calling the slot. check_nargs : Optional[bool] If `True` and the provided `slot` requires more positional arguments than the signature of this Signal, raise `TypeError`. by default `True`. thread: Thread | Literal["main", "current"] | None If `None` (the default), this slot will be invoked immediately when a signal is emitted, from whatever thread emitted the signal. If a thread object is provided, then the callback will only be immediately invoked if the signal is emitted from that thread. Otherwise, the callback will be added to a queue. **Note!**, when using the `thread` parameter, the user is responsible for calling `psygnal.emit_queued()` in the corresponding thread, otherwise the slot will never be invoked. (See note above). (The strings `"main"` and `"current"` are also accepted, and will be interpreted as the `threading.main_thread()` and `threading.current_thread()`, respectively). check_types : Optional[bool] If `True`, An additional check will be performed to make sure that types declared in the slot signature are compatible with the signature declared by this signal, by default `False`. unique : Union[bool, str, None] If `True`, returns without connecting if the slot has already been connected. If the literal string "raise" is passed to `unique`, then a `ValueError` will be raised if the slot is already connected. By default `False`. max_args : Optional[int] If provided, `slot` will be called with no more more than `max_args` when this SignalInstance is emitted. (regardless of how many arguments are emitted). on_ref_error : {'raise', 'warn', 'ignore'}, optional What to do if a weak reference cannot be created. If 'raise', a ReferenceError will be raised. If 'warn' (default), a warning will be issued and a strong-reference will be used. If 'ignore' a strong-reference will be used (silently). priority : int The priority of the callback. This is used to determine the order in which callbacks are called when multiple are connected to the same signal. Higher priority callbacks are called first. Negative values are allowed. The default is 0. Raises ------ TypeError If a non-callable object is provided. ValueError If the provided slot fails validation, either due to mismatched positional argument requirements, or failed type checking. ValueError If `unique` is `True` and `slot` has already been connected. ct|std| j5 r| vr dk(r td|cdddSd}r&|$ j | j \}}}|rd}r>|xs t |}t | j |sd|d} j||t|| j| } t| } j|ddd|S#1swY|SxYw) Nz'Cannot connect to non-callable object: raisezUSlot already connect. Use `connect(..., unique=False)` to allow duplicate connectionsignorez - Slot types z do not match types in signal.rrrr)r) callablerrr> _check_nargsrm_parameter_types_match_raise_connection_errorr' _try_discardr" _append_slot) rr _on_ref_errslot_sigisqtextracbrrrrgrrs rA_wrapperz(SignalInstance.connect.._wrappers+ D>"I$ PQQ &ddl((=  & &.2H$4/3/@/@t~~/V,Hh&. ':9T?H1$Q"/z9W X44T5A"%!..!,% %'6:B!!"%; &<K= &<KsC7 B$C77D)rr.r int | Nonerr*rHr.)r\r]) rgrrrrrrrrrs ` ```` ` rArzSignalInstance.connect`stt  66K  66K$,*6& &  & (&  & & P )rgcallback missing_oks rArzSignalInstance._try_discard s/    h '  s  ##)rrc <|turtjdtdd}t ||st d|d||j 5t||td||j||}|j|ddd|S#1swYSxYw) a Bind an object attribute to the emitted value of this signal. Equivalent to calling `self.connect(functools.partial(setattr, obj, attr))`, but with additional weakref safety (i.e. a strong reference to `obj` will not be retained). The return object can be used to [`disconnect()`][psygnal.SignalInstance.disconnect], (or you can use [`disconnect_setattr()`][psygnal.SignalInstance.disconnect_setattr]). Parameters ---------- obj : object An object. attr : str The name of an attribute on `obj` that should be set to the value of this signal when emitted. maxargs : Optional[int] max number of positional args to accept on_ref_error: {'raise', 'warn', 'ignore'}, optional What to do if a weak reference cannot be created. If 'raise', a ReferenceError will be raised. If 'warn' (default), a warning will be issued and a strong-reference will be used. If 'ignore' a strong-reference will be used (silently). priority : int The priority of the callback. This is used to determine the order in which callbacks are called when multiple are connected to the same signal. Higher priority callbacks are called first. Negative values are allowed. The default is 0. Returns ------- Tuple (weakref.ref, name, callable). Reference to the object, name of the attribute, and setattr closure. Can be used to disconnect the slot. Raises ------ ValueError If this is not a single-value signal AttributeError If `obj` has no attribute `attr`. Examples -------- >>> class T: ... sig = Signal(int) >>> class SomeObj: ... x = 1 >>> t = T() >>> my_obj = SomeObj() >>> t.sig.connect_setattr(my_obj, "x") >>> t.sig.emit(5) >>> assert my_obj.x == 5 zThe default value of maxargs will change from `None` to `1` in version 0.11. To silence this warning, provide an explicit value for maxargs (`None` for current behavior, `1` for future behavior).rXrYNObject  has no attribute rr) _NULLrdre FutureWarninghasattrr|rr%rrr)rgobjattrmaxargsrrcallers rAconnect_setattrzSignalInstance.connect_setattrs| e  MMR  GsD! 73%/A$!JK K ZZ & lG4**)! F   f % &  & s 7BBc|j5t||d}|j||dddy#1swYyxYw)aDisconnect a previously connected attribute setter. Parameters ---------- obj : object An object. attr : str The name of an attribute on `obj` that was previously used for `connect_setattr`. missing_ok : bool If `False` and the provided `slot` is not connected, raises `ValueError`. by default `True` Raises ------ ValueError If `missing_ok` is `True` and no attribute setter is connected. rrN)rr%r)rgrrrrs rAdisconnect_setattrz!SignalInstance.disconnect_setattrrs>*ZZ .S$X>B   b* - . . .s !7Ac 8|turtjdtdd}t |dst d|d|j 5t||td||j|| }|j|ddd|S#1swYSxYw) aBind a container item (such as a dict key) to emitted value of this signal. Equivalent to calling `self.connect(functools.partial(obj.__setitem__, attr))`, but with additional weakref safety (i.e. a strong reference to `obj` will not be retained). The return object can be used to [`disconnect()`][psygnal.SignalInstance.disconnect], (or you can use [`disconnect_setitem()`][psygnal.SignalInstance.disconnect_setitem]). Parameters ---------- obj : object An object. key : str Name of the key in `obj` that should be set to the value of this signal when emitted maxargs : Optional[int] max number of positional args to accept on_ref_error: {'raise', 'warn', 'ignore'}, optional What to do if a weak reference cannot be created. If 'raise', a ReferenceError will be raised. If 'warn' (default), a warning will be issued and a strong-reference will be used. If 'ignore' a strong-reference will be used (silently). priority : int The priority of the callback. This is used to determine the order in which callbacks are called when multiple are connected to the same signal. Higher priority callbacks are called first. Negative values are allowed. The default is 0. Returns ------- Tuple (weakref.ref, name, callable). Reference to the object, name of the attribute, and setitem closure. Can be used to disconnect the slot. Raises ------ ValueError If this is not a single-value signal TypeError If `obj` does not support __setitem__. Examples -------- >>> class T: ... sig = Signal(int) >>> t = T() >>> my_obj = dict() >>> t.sig.connect_setitem(my_obj, "x") >>> t.sig.emit(5) >>> assert my_obj == {"x": 5} zThe default value of maxargs will change from `None` to `1` inversion 0.11. To silence this warning, provide an explicit value for maxargs (`None` for current behavior, `1` for future behavior).rXrYN __setitem__r does not support __setitem__rr) rrdrerrrrr&rrr)rgrkeyrrrrs rAconnect_setitemzSignalInstance.connect_setitemsx e  MMR  GsM*gcU*GHI I ZZ & lG4**)! F   f % &  & s 7BBct|dstd|d|j5t||d}|j ||dddy#1swYyxYw)aDisconnect a previously connected item setter. Parameters ---------- obj : object An object. key : str The name of a key in `obj` that was previously used for `connect_setitem`. missing_ok : bool If `False` and the provided `slot` is not connected, raises `ValueError`. by default `True` Raises ------ ValueError If `missing_ok` is `True` and no item setter is connected. rrrrrN)rrrr&r)rgrrrrs rAdisconnect_setitemz!SignalInstance.disconnect_setitems]*sM*gcU*GHI I ZZ 2 cAF   fj 1 2 2 2s !AAc t|} t |\}}|t|jx}kDrd|d|}|j||t |trd|d fS||d fS#t$r$}tj|ddYd}~yd}~wwxYw#t$r%}t |t rt|d|d}~wwxYw) aMake sure slot is compatible with signature. Also returns the maximum number of arguments that we can pass to the slot Returns ------- slot_sig : Signature | None The signature of the slot, or None if it could not be determined. maxargs : int | None The maximum number of arguments that we can pass to the slot. is_qt : bool Whether the slot is a Qt slot. z;. To silence this warning, connect with `check_nargs=False`rXrYN)NNFzM. (Note: prefer using positional args with functools.partials when possible).z- Slot requires at least z. positional arguments, but spec only provides T) _get_signature_possibly_qtr>rdre_acceptable_posarg_rangerarrc parametersrr;) rgrspecreminargsr n_spec_paramsrs rArzSignalInstance._check_nargss  %1$7H 7A GW s4??';;m <+G9555BOE   ( (u 5!(C0tMMhMM1 % MM#TT %  % $( c99   s. A*B* B3BB C# CCct|dt|}d|dt|d}||z }|d|jz }t|)NrIzCannot connect slot z with signature: : z Accepted signature: )rr;rmr>)rgrrrSmsgs rArz&SignalInstance._raise_connection_error)sXtZT3$TH,=io=NcR u  )$..)9::orCc|j5t|dtfdt|jDdcdddS#1swYyxYw)zBGet index of `slot` in `self._slots`. Return -1 if not connected.rrc34K|]\}}|k(s |ywrErG).0rrnormeds rA z-SignalInstance._slot_index..6sMtq!fMs N)rr'nextrr)rgrrs @rA _slot_indexzSignalInstance._slot_index0sJ ZZ S"4h?FMy'=MrR  S S Ss 5A  Ac|j5||jd dddy|j|}|dk7r|j|n|std|dddy#1swYyxYw)aDisconnect slot from signal. Parameters ---------- slot : callable, optional The specific slot to disconnect. If `None`, all slots will be disconnected, by default `None` missing_ok : Optional[bool] If `False` and the provided `slot` is not connected, raises `ValueError. by default `True` Raises ------ ValueError If `slot` is not connected and `missing_ok` is False. Nrrzslot is not connected: )rrrr>)rgrridxs rA disconnectzSignalInstance.disconnect8s"ZZ C|!!%( C C ""4(Cby!!#& #:4&!ABB C C CsA,8A,,A5c*|j|dk\S)z#Return `True` if slot is connected.r)rrs rA __contains__zSignalInstance.__contains__Us%**rCc,t|jS)z!Return number of connected slots.)rcrrls rA__len__zSignalInstance.__len__Ys4;;rCrrc z|jry|r |jj||rmt d|jt |Dcgc] }t |c}s8td|jdtd |Dd |j|jr|jj|ytj"d d lm}tj||||j!|y#t$r'}td|d|d|jd||d}~wwxYwcc}w) aEmit this signal with arguments `args`. !!! note `check_args` and `check_types` both add overhead when calling emit. Parameters ---------- *args : Any These arguments will be passed when calling each slot (unless the slot accepts fewer arguments, in which case extra args will be discarded.) check_nargs : bool If `False` and the provided arguments cannot be successfully bound to the signature of this Signal, raise `TypeError`. Incurs some overhead. by default False. check_types : bool If `False` and the provided arguments do not match the types declared by the signature of this Signal, raise `TypeError`. Incurs some overhead. by default False. Raises ------ TypeError If `check_nargs` and/or `check_types` are `True`, and the corresponding checks fail. NzCannot emit args z from signal z with signature rcyrErGrGrCrArz%SignalInstance.emit..rrCzTypes provided to 'z.emit' c3FK|]}t|jywrE)rrI)ras rArz&SignalInstance.emit..s8aa))8s!z do not match signal signature: rr()rrmbindrrrfrrSrrrrr,r_groupr)_run_emit_loop)rgrrargsr r#r)s rAemitzSignalInstance.emit]s=:      ###T* 5 $..*:d>> class T: ... sig = Signal(int) >>> t = T() >>> t.sig.pause() >>> t.sig.emit(1) >>> t.sig.emit(2) >>> t.sig.emit(3) >>> t.sig.resume(lambda a, b: (a[0].union(set(b)),), (set(),)) >>> # results in t.sig.emit({1, 2, 3}) FrNrr ReducerOneArgReducerTwoArgs) rrrcrrrinspectrmrrrr r&)rgreducerinitialr's rAresumezSignalInstance.resume sD t]D1  t{{ q    " " $   7$$W-889Q>5tOW5d6F6FG/9e#!'4+;+;>> with obj.signal.paused(lambda a, b: (a[0].union(set(b)),), (set(),)): ... t.sig.emit(1) ... t.sig.emit(2) ... t.sig.emit(3) >>> # results in obj.signal.emit({1, 2, 3}) ) _SignalPauser)rgrNrOs rApausedzSignalInstance.pausedDs@T7G44rCcJd}|Dcic]}|t||}}|j|d<|jDcgc]}t|ts|c}|d<t |jt |dkDrt jdd|Scc}wcc}w)z)Return dict of current state, for pickle.) rbr[rrrr\r]rrr^rrrrzJPickling a SignalInstance does not copy connected weakly referenced slots.rXrY)rrrrar#rcrdre)rgattrsrddxs rA __getstate__zSignalInstance.__getstate__fs  5: :DdGD$'' : :..*;#';;Pa*Q2OP8 t{{ c"X,/ / MM   ;PsBB B c|jD].\}}|dk(r|j||_"t|||0t j |_|jtjk(r|j|_ y|jtjk(r|j|_ y|j|_ y)zRestore state from pickle.rN)itemsrrr{rrrr^r6r8rrr9rr)rgstatekvs rA __setstate__zSignalInstance.__setstate__sKKM $DAqK!%!3!3A!6a#  $ __&   ~44 4(,(B(BD %   !6!6 6(,(G(GD %(,(E(ED %rC)rmzSignature | tuplerurrSrrTrrUrrVr3rHr)rurrHzCallable[[], Any]rr)rHr;)r4threading.Thread | Literal['main', 'current'] | Noner bool | Nonerr`r bool | strrrrr*rrrHzCallable[[F], F])rr.rr_rr`rr`rrarrrr*rrrHr.rE)rzF | Nonerr_rr`rr`rrarrrr*rrrHzCallable[[F], F] | F)rr$rHr)rz#Literal['all'] | int | WeakCallbackrHrT)rr$rrrHr) robjectrr;rint | None | objectrr*rrrHWeakCallback[None])rrcrr;rrrHr) rrcrr;rrdrr*rrrHre)rrcrr;rrrHr)rrr r rHz)tuple[Signature | None, int | None, bool])rQ)rrrr;rHr)rrrHr)NT)rzCallable | NonerrrHr)rrrHr)rHr)r'rrrrrrHr)r'ztuple[Any, ...]rHrrHrrG)rAIterable[str | SignalInstance]rHr)rHContextManager[None])rNReducerFunc | NonerOrrHr)rNrjrOrrHri)rHdict)r[rkrHr)0rIrJrKrLrrMrr_empty_signaturer4rirNrrrmrurSrrrrrrrrrrrrrrrrrr(r*r&rrrrBrDrGrIrPrSrXr^rGrCrAr,r,s7rKJCGK@G(8)&'+',$6)&$)& )&  )& !% )&!%)&")& )&V$$    : HK#&#& #'* E !  !    %      HK#&#& #'*  E  !  !   %     G<HL#'#'"#'-G<G<E G< ! G< ! G<G<G<%G<G< G..!$.26. .:(- T (.T TT% T % TT Tn9=22 #2152 28*N*N$-*N 2*NXSC:+ /4;";"'+;"BF;" ;"|/4RR'+RBFR R $)L  !$.488!v-1 5) 5;> 5  5D8FrCr,c6eZdZdZ d ddZddZd dZy) rFz.Context manager to block and unblock a signal.cB||_||_|j|_yrE)_signal_excluder _was_blocked)rgr-rAs rAriz_SignalBlocker.__init__s   "..rCcP|jj|jy)N)rA)rorBrprls rA __enter__z_SignalBlocker.__enter__s 4==1rCcR|js|jjyyrE)rqrorDrgr's rA__exit__z_SignalBlocker.__exit__s   LL "!rCNrg)r-r,rArhrHrrfr'rrHrrIrJrKrLrirsrvrGrCrArFrFs38QS/$//M/ /2#rCrFc8eZdZdZ ddZddZddZy) rRz-Context manager to pause and resume a signal.cP|j|_||_||_||_yrE)r _was_pausedro_reducer_initial)rgr-rNrOs rAriz_SignalPauser.__init__s'",,   rCc8|jjyrE)rorIrls rArsz_SignalPauser.__enter__s rCc~|js1|jj|j|jyyrE)r{rorPr|r}rus rArvz_SignalPauser.__exit__s, LL   t}} = rCN)r-r,rNrjrOrrHrrfrwrxrGrCrArRrRs47 $ /A LO  >rCrRc tj|S#t$r]}tt5tj |st |cdddcYd}~S ddd||#1swY||xYwd}~wwxYwrE)rMrmr>rr2ismethod _stub_sig)rr s rArmrmss  %%  i  &##C( ~ & &( &Q &Q s7 A=A8 A* A8A= A8*A5 / A88A=r'rSkindkwargs)maxsizec ddl}tt|ddturt|dddk(st|turtS||j urt dt jt dt jd t d t jd t d t jd t dt jd g}t|Std)z0Called as a backup when inspect.signature fails.rN__self__rIr(r@rsepr)rSrdefaultend fileflushFzunknown object) builtinsrrr,_ANYSIGprintr VAR_POSITIONAL KEYWORD_ONLYr r>)rrparamss rArrs WS*d +,> CT *f 4 cn $ hnn 7)A)A B 5y'='=s K 5y'='=t L 6 (>(> M 7)?)? O    % &&rCc t|Dcgc]$\}}td|tj|&}}}t|Scc}}w)Np)rSr annotation)rr POSITIONAL_ONLYr )rhrtrs rArfrfsQe$ Aq 1#wY%>%>1MF V  s)Ac6t|}| t|S|SrE)_guess_qtsignal_signaturerm)rsigs rArrs! $D )C!k9T?2s2rCrct|trXd|vrtd||jdddjddd}|r|j ddzndx}}||fSd}d}d}t j t jh}|jjD]} | j|vr(| jt jur|dz }3|dz }9| jt jurd}X| jt jusu| jt jus|std |||rd fS||zfS) aReturn tuple of (min, max) accepted positional arguments. Parameters ---------- sig : Signature Signature object to evaluate forbid_required_kwarg : Optional[bool] Whether to allow required KEYWORD_ONLY parameters. by default True. Returns ------- arg_range : Tuple[int, int] minimum, maximum number of acceptable positional arguments Raises ------ ValueError If the signature has a required keyword_only parameter and `forbid_required_kwarg` is `True`. (z&Unrecognized string signature format: r)r,FTz2Unsupported KEYWORD_ONLY parameters in signature: N)rar;r>splitcountr rPOSITIONAL_OR_KEYWORDrvaluesrremptyrr) rforbid_required_kwarginnerr rrequiredoptionalposargs_unlimited _pos_requiredparams rArrsW.#s c>EcWMN N #q!!$**321549EKK,q0q@'HH.. 0O0OPM&&( Y :: &}} /A A  ZZ933 3 $  JJ)00 0 0%QRUQVWX X Y /d IIX5H IIrCc|xs t|}d}t|jj|jjD]p\}}|j}||j ur!t |tr(| t|}|j|j}t||jrpyy)aReturn True if types in `function` signature match those in `spec`. Parameters ---------- function : Callable A function to validate spec : Signature The Signature against which the `function` should be validated. func_sig : Signature, optional Signature for `function`, if `None`, signature will be inspected. by default None Returns ------- bool True if the parameter types match. NFT) rmziprrrrrar;rgetrS _is_subclass)functionr func_sigfsig func_hintsf_param spec_paramf_annos rArr8s(  *y*D"J"4??#9#9#;T__=S=S=UV ## TZZ   fc "!+H5 ^^GLL1FFJ$9$9:  rCct|s.t|turtfdt |DSt |S)z.Variant of issubclass with support for unions.c36K|]}t|ywrE) issubclass)rrrights rArz_is_subclass..bs@A:a'@s)r rranyrr)leftrs `rArr_s8 4=Z-6@$@@@ dE ""rCct|}d|jvrtd|jSt |dd}|dk(r td|j jS|dk(r:|jj drt|j jSd|jvr$d t |d dvrt|jSy ) zReturn string signature if `obj` is a SignalInstance or Qt emit method. This is a bit of a hack, but we found no better way: https://stackoverflow.com/q/69976089/1631624 https://bugreports.qt.io/browse/PYSIDE-1713 pyqtBoundSignalr;rKrQzpyqtBoundSignal.emitzSignalInstance.emitbuiltinr,QtCorerJN) rrIrr-rr startswith_ridiculously_call_emitr()rtype_qualnames rArrfs IEENN*E3::&&sNB/H))E3<<..//((U^^-F-Fy-Q's||'8'8995>>)h' |R;/'sxx00 rC)rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrc |ty#t$rG}dt|vr0t|jddj cYd}~SYd}~yd}~wwxYw)zACall SignalInstance emit() to get the signature from err message.z only acceptsrN) _CRAZY_ARGSrr;rstrip)rr s rArrs[;  ; SV #q6<</288: : $ ;s A7A AAr-cV|dk(rttdStdtd|)Nr-__mypyc_attrs__zmodule r)rr+r|rI)rSs rA __getattr__rs1 {v011 78,.@I JJrC)rrrHzinspect.Signature)rrrHr )rhrrHr )rrrHSignature | strrb)rrrrrHztuple[int, int | None]rE)rrr r rzSignature | NonerHr)rrrrrHr)rrrHr)rrrHr)rSr;rHr)ZrL __future__rrMsysrrdr collectionsr contextlibrr functoolsrrr r r r typingr rrrrrrrrrrrrrrrrr _exceptionsr _mypycr!_queuer"_weak_callbackr#r$r%r&r'r%r)r*rrKrL ReducerFunc__all__rcrr.getrecursionlimitr>r3set__args__rFr4rMr6r+rlr,rFrRrmr VAR_KEYWORDrrrfrrrrrrrrrGrCrArs }~# /0011*'"$.huo.56Muene34N ~56K 4 Cx '#'')<= }--.$/M/   ,[?[?|; .TFTF/TFn##$>>. vI$<$<=xi&;&;<  4''6&39=0J 0J150J0JhGK$$'$3C$ $N#8  KrC