iaSSKJrJr SSKrSSKrSSKrSSKJr SSKJ r J r J r SSK J r Jr SSKJrJr SSKJr "SS \5rg) )absolute_importunicode_literalsN)SpyCall)ExistingSpyErrorIncompatibleFunctionErrorInternalKGBError)iterkeyspyver) FunctionSig _UNSET_ARG)is_attr_defined_on_ancestorcl\rSrSrSr\R r\Rr\Rr/SQr /SSS.r 0r SSS\ S4Sjr \S 5r\S 5r\S 5r\S 5r\S 5r\S5rS$SjrSrSrSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#Sr$Sr%S r&S%S!jr'S"r(S#r)g)& FunctionSpyaA spy infiltrating a function. A FunctionSpy takes the place of another function. It will record any calls made to the function for later inspection. By default, a FunctionSpy will allow the call to go through to the original function. This can be disabled by passing call_original=False when initiating the spy. If disabled, the original function will never be called. This can also be passed a call_fake parameter pointing to another function to call instead of the original. If passed, this will take precedence over call_original. ) call_original called_withlast_called_withraised last_raisedreturned last_returnedraised_with_messagelast_raised_with_message reset_callsunspyFN)callscalled last_callTc[R"5UlUbUb [S5e[ US5(a [ U5e[ U5(a][ U[R5(a>[ U[R5(d-[ U[R5(d[SU-5e[UUUS9nXl U[LaX`RLaURUR:Xa [S5e[ X`R 5(d [S5eURUR":Xd'[$SS :Xa%URUR&:Xa [S 5eUR((a%URUR&:Xa [S 5eUbUbeUR+U5nUceUbJ[ U5(d[S U-5e[UUS 9n UR-U 5(d [/UUUU S9eXlX lUR4UlUR9UR25UlUR=5(aEURR>RAUR 5Ul!URE5 OUR2Ul!U(aX0l#O U(aUR2Ul#OSUl#URIU5 URFUR2La*UR9URFURJS9Ul#gg)adInitialize the spy. This will begin spying on the provided function or method, injecting new code into the function to help record how it was called and what it returned, and adding methods and state onto the function for callers to access in order to get those results. Version Added: 7.0: Added support for specifying an explicit function name using ``func_name=``. Version Added: 5.0: Added support for specifying an instance in ``owner`` when spying on bound methods using decorators that return plain functions. Args: agency (kgb.agency.SpyAgency): The spy agency that manages this spy. func (callable): The function or method to spy on. call_fake (callable, optional): The optional function to call when this function is invoked. This cannot be specified if ``op`` is provided. call_original (bool, optional): Whether to call the original function when the spy is invoked. If ``False``, no function will be called. This is ignored if ``call_fake`` or ``op`` are provided. op (kgb.spies.BaseOperation, optional): An operation to perform. This cannot be specified if ``call_fake`` is provided. owner (type or object, optional): The owner of the function or method. If spying on an unbound method, this **must** be set to the class that owns it. If spying on a bound method that identifies as a plain function (which may happen if the method is decorated and dynamically returns a new function on access), this should be the instance of the object you're spying on. func_name (str, optional): An explicit name for the function. This will be used instead of the function's specified name, and is usually a sign of a bad decorator. Version Added: 7.0 Nz)op and call_fake cannot both be provided.spyzK%r cannot be spied on. It does not appear to be a valid function or method.)funcowner func_namez@This function has no owner, but an owner was passed to spy_on().z3The owner passed does not contain the spied method.rzEThe owner passed does not match the actual owner of the bound method.zUnable to spy on unbound slippery methods (those that return a new function on each attribute access). Please spy on an instance instead.zU%r cannot be used for call_fake. It does not appear to be a valid function or method.)r#)r!func_sigincompatible_funcincompatible_func_sig)code)&inspect currentframe init_frame ValueErrorhasattrrcallabler FUNC_NAME_ATTRMETHOD_SELF_ATTRFUNC_GLOBALS_ATTR_sigr r" func_type TYPE_FUNCTIONr#TYPE_BOUND_METHODr TYPE_UNBOUND_METHOD is_slipperysetupis_compatible_withragency orig_func real_func _real_func_clone_function_call_orig_func_get_owner_needs_patching__dict__get_owner_func_attr_value _patch_ownerr!_build_proxy_func _old_code) selfr:r! call_fakeropr"r#sig call_fake_sigs H/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/kgb/spies.py__init__FunctionSpy.__init__<s~"..0 >i3HI I 4  "4( (k8899{;;<<{<<==>#$% %t %$-/  "uJJ'>~~!3!33 #$$unn55$&566nn(>(>>Qx1}~~)A)AA$,-- OO NNd66 6() ) >$ $$I( ((  I&& "P#,"-..( 2;=M))-88/ &/*7 99 --#33DNNC  ) ) + + ##''7  '    *...D ' !I DIDI t$ 99 &,,TYY26..-BDI 'c.URR$)zThe type of function being spied on. This will be one of :py:attr:`TYPE_FUNCTION`, :py:attr:`TYPE_UNBOUND_METHOD`, or :py:attr:`TYPE_BOUND_METHOD`. Type: int )r2r3rGs rLr3FunctionSpy.func_typesyy"""rOc.URR$)z8The name of the function being spied on. Type: str )r2r#rQs rLr#FunctionSpy.func_namesyy"""rOc.URR$)ztThe owner of the method, if a bound or unbound method. This will be ``None`` if there is no owner. Type: type )r2r"rQs rLr"FunctionSpy.owner syyrOcPURR$![a gf=f)z'Whether or not the spy was ever called.F)r=rAttributeErrorrQs rLrFunctionSpy.calleds) ??)) )    %%cTURR$![a /s$f=f)zUThe list of calls made to the function. Each is an instance of :py:class:`SpyCall`. )r=rrXrQs rLrFunctionSpy.callss+  ??(( ( I s  ''cPURR$![a gf=f)z^The last call made to this function. If a spy hasn't been called yet, this will be ``None``. N)r=rrXrQs rLrFunctionSpy.last_call)s)  ??,, ,  rZcURnURn[US5(de[R[ U5 U?[UR5Hn[X$5 M URHn[X%5 M [U[RUR5 Ub&URX0R UR"5 U(a&UR$R&R)U5 gg)aORemove the spy from the function, restoring the original. The spy will, by default, be removed from the registry's list of spies. This can be disabled by passing ``unregister=False``, but don't do that. That's for internal use. Args: unregister (bool, optional): Whether to unregister the spy from the associated agency. r N)r=r"r-r_spy_mapidr r _FUNC_ATTR_DEFAULTSdelattr_PROXY_METHODSsetattrr FUNC_CODE_ATTRrF _set_methodr#rCr:spiesremove)rG unregisterr<r" attr_namer#s rLrFunctionSpy.unspy4sOO  y%((((  D * M!$":":;I I )<,,I I )-  ;55t~~F     UNN!88 :  KK   $ $T * rOc URUR:Xa UR"UR/UQ70UD6$URUR:XayU(a[ USUR5(dT[ SURR<SURR<SURR<S35eUR"U0UD6$)aCall the original function being spied on. The function will behave as normal, and will not trigger any spied behavior or call tracking. Args: *args (tuple): The positional arguments to pass to the function. **kwargs (dict): The keyword arguments to pass to the function. Returns: object: The return value of the function. Raises: Exception: Any exceptions raised by the function. rzThe first argument to z(.call_original() must be an instance of .z", since this is an unbound method.) r3r5r?r"r6 isinstance TypeError__name__ __module__rGargskwargss rLrFunctionSpy.call_originalVs* >>T33 3'' DTDVD D~~!9!99:d1gtzz#B#B# //88::00::.. 011''88 8rOcF^^[UU4SjUR55$)a@Return whether the spy was ever called with the given arguments. This will check each and every recorded call to see if the arguments and keyword arguments match up. If at least one call does match, this will return ``True``. Not every argument and keyword argument made in the call must be provided to this method. These can be a subset of the positional and keyword arguments in the call, but cannot contain any arguments not made in the call. Args: *args (tuple): The positional arguments made in the call, or a subset of those arguments (starting with the first argument). **kwargs (dict): The keyword arguments made in the call, or a subset of those arguments. Returns: bool: ``True`` if there's at least one call matching these arguments. ``False`` if no call matches. c3H># UHnUR"T0TD6v M g7fN)r).0callrtrus rL *FunctionSpy.called_with..s( "   d -f -""anyrrss ``rLrFunctionSpy.called_withzs#4     rOcTURnUSL=(a UR"U0UD6$)aReturn whether the spy was last called with the given arguments. Not every argument and keyword argument made in the call must be provided to this method. These can be a subset of the positional and keyword arguments in the call, but cannot contain any arguments not made in the call. Args: *args (tuple): The positional arguments made in the call, or a subset of those arguments (starting with the first argument). **kwargs (dict): The keyword arguments made in the call, or a subset of those arguments. Returns: bool: ``True`` if the last call's arguments match the provided arguments. ``False`` if they do not. N)rr)rGrtrur{s rLrFunctionSpy.last_called_withs-,~~4ED$4$4d$Ef$EErOcB^[U4SjUR55$)aReturn whether the spy was ever called and returned the given value. This will check each and every recorded call to see if any of them returned the given value. If at least one call did, this will return ``True``. Args: value (object): The expected returned value from the call. Returns: bool: ``True`` if there's at least one call that returned this value. ``False`` if no call returned the value. c3F># UHnURT5v M g7fry)r)rzr{values rLr|'FunctionSpy.returned..s$ " MM% "!r)rGrs `rLrFunctionSpy.returned#      rOcRURnUSL=(a URU5$)zReturn whether the spy's last call returned the given value. Args: value (object): The expected returned value from the call. Returns: bool: ``True`` if the last call returned this value. ``False`` if it did not. N)rr)rGrr{s rLrFunctionSpy.last_returneds&~~48DMM%$88rOcB^[U4SjUR55$)aReturn whether the spy was ever called and raised this exception. This will check each and every recorded call to see if any of them raised an exception of a given type. If at least one call does match, this will return ``True``. Args: exception_cls (type): The expected type of exception raised by a call. Returns: bool: ``True`` if there's at least one call raising the given exception type. ``False`` if no call matches. c3F># UHnURT5v M g7fry)r)rzr{ exception_clss rLr|%FunctionSpy.raised..s$ " KK & &"rr)rGrs `rLrFunctionSpy.raisedrrOcRURnUSL=(a URU5$)aReturn whether the spy's last call raised this exception. Args: exception_cls (type): The expected type of exception raised by a call. Returns: bool: ``True`` if the last call raised the given exception type. ``False`` if it did not. N)rr)rGrr{s rLrFunctionSpy.last_raiseds&~~4>DKK $>>rOcF^^[UU4SjUR55$)a0Return whether the spy's calls ever raised this exception/message. This will check each and every recorded call to see if any of them raised an exception of a given type with the given message. If at least one call does match, this will return ``True``. Args: exception_cls (type): The expected type of exception raised by a call. message (unicode): The expected message from the exception. Returns: bool: ``True`` if there's at least one call raising the given exception type and message. ``False`` if no call matches. c3H># UHnURTT5v M g7fry)r)rzr{rmessages rLr|2FunctionSpy.raised_with_message..s( "  $ $]G < <"r~r)rGrrs ``rLrFunctionSpy.raised_with_messages#&     rOcRURnUSL=(a URX5$)aaReturn whether the spy's last call raised this exception/message. Args: exception_cls (type): The expected type of exception raised by a call. message (unicode): The expected message from the exception. Returns: bool: ``True`` if the last call raised the given exception type and message. ``False`` if it did not. N)rr)rGrrr{s rLr$FunctionSpy.last_raised_with_messages/~~D A((@ BrOcj/URlSURlSURlg)z-Reset the list of calls recorded by this spy.FN)r=rrrrQs rLrFunctionSpy.reset_calls)s& "!&$(!rOcUnURURUR4;aUSSnURnURnUR n[ XU5nURRU5 SUl Xul UcSnU$UR(a?URRUR5nUR(aU"U0UD6nO U"U0UD6nXlU$![ a n XleSn A ff=f)aCall the original function or fake function for the spy. This will be called automatically when calling the spied function, recording the call and the results from the call. Args: *args (tuple): Positional arguments passed to the function. **kwargs (dict): All dictionary arguments either passed to the function or default values for unspecified keyword arguments in the function signature. Returns: object: The result of the function call. NT)r3r5r6r2r=r!rrappendrr has_getter defined_func__get__r"r7 Exception exception return_value) rGrtru record_argsrJr<r!r{resultes rL__call__FunctionSpy.__call__/s& >>d44"668 8%ab/KiiOO yyt&1t$ " <F0 - >>!--55djjAF"(!8!8"4262F !'   !" sAC/C// D9DDcURnXR:XaSnURnOURnXR:Xa=URR nU[ LaURnSnO,URnSnOXR:XaURnSnW<SUR<SU<3n[UR5nUS:XaSnOS nS WU[UR5U4-$) zReturn a string representation of the spy. This is mainly used for debugging information. It will show some details on the spied function and call log. Returns: unicode: The resulting string representation. function classmethodz bound methodzunbound methodrnz of rr{rz) r3r4r#r"r5 __class__typerqr6lenr) rGr3 func_type_strqualnamer" owner_cls class_name call_count calls_strs rL__repr__FunctionSpy.__repr__lsNN ** *&M~~HJJE222!JJ00 $!&J$1M!*!3!3J$2M666"^^ 0 (2DNNEJH_ ?II(M8,/ OY,HH HrOcURnUSL=(aT [R"U5(+=(d2 URR=(d [ XR 5$)afReturn whether the owner (if any) needs to be patched. Owners need patching if they're an instance, if the function is slippery, or if the function is defined on an ancestor of the class and not the class itself. See :py:meth:`_patch_owner` for what patching entails. Returns: bool: ``True`` if the owner needs patching. ``False`` if it does not. N)r"r)isclassr2r7r r#)rGr"s rLr@%FunctionSpy._get_owner_needs_patchingsU T!E__U++D&&D,UNNC FrOcURUR5nURnURUR:Xa\X/n[ SS:aUR U5 URX R[R"XR55 OURX RU5 Xlg)aPatch the owner. This will create a new method in place of an existing one on the owner, in order to ensure that the owner has its own unique copy for spying purposes. Patching the owner will avoid collisions between spies in the event that the method being spied on is defined by a parent of the owner, rather than the owner itself. See :py:meth:`_get_owner_needs_patching` the conditions under which patching will occur. rN) r>r=r"r3r5r rrgr#types MethodType)rGr<r"method_type_argss rLrDFunctionSpy._patch_owners&((9   >>T33 3 )1 Qx1} ''.   UNN"--iD F   UNNI >#rOc URn[U5nURnURUUUS9nUR X5upgX`l[ U[RU5 U[RU'Xl URR[R"UR 55 UR"H*n[%XH5(ae[ XH['X55 M, g)aBuild the proxy function used to forward calls to this spy. This will construct a new function compatible with the signature of the provided function, which will call this spy whenever it's called. The bytecode of the provided function will be set to that of the generated proxy function. See the comment within this function for details on how this works. Args: func (callable): The function to proxy. )r!rJspy_idN)r2rar=_compile_forwarding_call_func_build_spy_coderFrer rfrr`r rAupdatecopydeepcopyrbrdr-getattr) rGr!rJrr<forwarding_callold_codenew_codeproxy_func_names rLrEFunctionSpy._build_proxy_funcs|iiDOO <<= "11$H! ;55x@(, V$  !!$--0H0H"IJ#22Oy:: :: I0N O 3rOcURRn[U5nU(a)SSRURR5-nOSnSUR 5UR 5UUS.-nU(aSUSRSU55S.-nOS U-n0n [ [US S 5[5U 5 U(a U S"5n OU Sn U ceU $![an [S UU US .-5eSn A ff=f)aCompile a forwarding call function for the spy. This will build the Python code for a function that approximates the function we're spying on, with the same function definition and closure behavior. Version Added: 7.1 Args: func (callable): The function being spied on. sig (kgb.signature.BaseFunctionSig): The function signature to use for this function. spy_id (int): The ID used for the spy registration. Returns: callable: The resulting forwarding function. z (%s) z, z def _kgb_forwarding_call(%(params)s): from kgb.spies import FunctionSpy as _kgb_cls %(use_closure_vars)s _kgb_l = locals() return _kgb_cls._spy_map[%(spy_id)s](%(call_args)s) ) call_argsparamsruse_closure_varszadef _kgb_forwarding_call_closure(%(params)s): %(forwarding_call)s return _kgb_forwarding_call c3,# UH nSU-v M g7f)z%s=NoneN)rz_vars rLr|.s($0D"D($0s)rrzif 1: %szexeczBUnable to compile a spy function for %(func)r: %(error)s %(code)s)r(errorr!N_kgb_forwarding_call_closure_kgb_forwarding_call) __code__ co_freevarsbooljoinformat_forward_call_argsformat_arg_specevalcompileglobalsrr) rGr!rJr closure_vars use_closureuse_closure_vars_strforwarding_call_str func_code_str exec_localsrrs rLr)FunctionSpy._compile_forwarding_call_funcIs\0}}00 <(   !))DMM5567 ! $&  L !99;--/ $8     4(;"ii($0(   %&     F;K ) )*HIKO)*@AO***) "*   s( C&& D0DDc[U[R5n[U[R5nX4:wde[US5(aSUR0n[ S:aUR US'[ S:aQUR[R[R-[R--nURU-US'UR"S0UD6nOUR/n[ S:aURUR5 UUR UR"URUR$UR&UR(UR*UR,URUR.UR0UR2UR4/ - n[6R8"U6nXs:wdeXt:wdeX74$)aBuild a CodeType to inject into the spied function. This will create a function bytecode object that contains a mix of attributes from the original function and the forwarding call. The result can be injected directly into the spied function, containing just the right data to impersonate the function and call our own logic. Version Added: 7.1 Args: func (callable): The function being spied on. forwarding_call (callable): The spy forwarding call we built. Returns: tuple: A 2-tuple containing: 1. The spied function's code object (:py:class:`types.CodeType`). 1. The new spy code object (:py:class:`types.CodeType`). replaceco_name)r co_qualnameco_flags)rrr)rr rfr-rr rrr) CO_GENERATOR CO_COROUTINECO_ASYNC_GENERATORr co_argcountrco_kwonlyargcount co_nlocals co_stacksizeco_code co_constsco_names co_varnames co_filenameco_firstlineno co_lnotabr co_cellvarsrCodeType) rGr!rr temp_codereplace_kwargs mirror_flagsr code_argss rLrFunctionSpy._build_spy_codes44!;!;<O[-G-GH $$$ 8Y ' '8++N080D0D}-,'00(((()../ 0 .7-?-?,-Nz* ((:>:H #../I  !FunctionSpy._clone_function.s$((  =GD+"<"<= D+77 8 D+44 5 D+88 9 D+77 8 :  8q=> 4==9L+MN>rOc[R"U5(aUc [X5 g[XU5 gUc[R X5 g[RXU5 g![ a+n[U5S:XaURU SnAgSnAgSnAff=f![ a,n[U5S:XaX1RU'SnAgSnAgSnAff=f)aSet a new method on an object. This will set the method (or delete the attribute for one if setting ``None``). If setting on a class, this will use a standard :py:func:`setattr`/:py:func:`delattr`. If setting on an instance, this will use a standard :py:meth:`object.__setattr__`/:py:meth:`object.__delattr__` (in order to avoid triggering a subclass-defined version of :py:meth:`~object.__setattr__`/:py:meth:`~object.__delattr__`, which might lose or override our spy). Args: owner (type or object): The class or instance to set the method on. name (unicode): The name of the attribute to set for the method. method (types.MethodType): The method to set (or ``None`` to delete). Nz/can't apply this __delattr__ to instance objectz/can't apply this __setattr__ to instance object) r)rrcreobject __delattr__rpstrrA __setattr__)rGr"namemethodrs rLrgFunctionSpy._set_methodPs2 ??5 ! !~$V, ^ -""5/ 2""57 -q6NN t, O - 2q6NN,2NN4(O 2s/A*B"* B4BB" C,CC) r?rFrCr=r2r:r!r+r;)Try)*rqrr __qualname____firstlineno____doc__r r4r5r6rdrbr`r rMpropertyr3r#r"rrrrrrrrrrrrrrrrr@rDrErrr>rg__static_attributes__rrOrLrrsR   --M $55 &99N H/34 dxBt # ### +D"9H >F4 *9  *?  0B() ;z+HZF(!$FwPrsjn"` D/2rOr) __future__rrrr)r kgb.callsr kgb.errorsrrr kgb.pycompatr r kgb.signaturer r kgb.utilsr rrrrOrLr#s78  **)11o2&o2rO