iOSrSSKJr SSKJr "SS\5r"SS\5r"SS \5r"S S \5r "S S \5r "SS\ 5r "SS\5r "SS\ 5r g)z(Planned operations for spies to perform.)unicode_literals)UnexpectedCallErrorc.\rSrSrSrSrSSjrSrSrg) BaseSpyOperationaIBase class for a spy operation. Spy operations can be performed when a spied-on function is called, handling it according to a plan provided by the caller. They're registered by passing ``op=`` when spying on the function. There are a handful of built-in operations in KGB, but projects can subclass this and define their own. c[e)aHandle a call to this operation. Args: spy_call (kgb.calls.SpyCall): The call to handle. *args (tuple): Positional arguments passed into the call. This will be normalized to not contain an object instance for bound method or class methods. **kwargs (tuple): Keyword arguments passed into the call. Returns: object: The value to return to the caller of the spied function. Raises: Exception: Any exception to raise to the caller of the spied function. NotImplementedError)selfspy_callargskwargss F/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/kgb/ops.py handle_callBaseSpyOperation.handle_calls ."!ct^UTlURUR:XaU(dU4SjnU$U4SjnU$)a@Set up the operation. This associates the spy with the operation, and then returns a fake function to set for the spy, which will in turn call the operation's handler. Args: spy (kgb.spies.FunctionSpy): The spy this operation is for. force_unbound (bool, optional): Whether to force building an unbound fake function. This is needed for any functions called by an operation itself (and is thus used for nested operations). Version Added: 6.1 Returns: callable: The fake function to set up with the spy. c(>TR"U0UD6$N _on_spy_call)_selfr rr s r fake_func)BaseSpyOperation.setup..fake_funcF(($9&99rc(>TR"U0UD6$rr)r rr s rrrIrr)spy func_typeTYPE_BOUND_METHOD)r r force_unboundrs` rsetupBaseSpyOperation.setup,s:. ==C11 1- :  :rcURnURnURUR:XaUR"USS0UD6(deOUR"U0UD6(deUR "U/UQ70UD6$)a/Internal handler for a call to this operation. This normalizes and sanity-checks the arguments and then calls :py:meth:`handle_call`. Args: *args (tuple): All positional arguments made in the call. This may include the object instance for bound methods or the class for classmethods. **kwargs (dict): All keyword arguments made in the call. Returns: object: The value to return to the caller of the spied function. Raises: Exception: Any exception to raise to the caller of the spied function. N)r last_callrTYPE_UNBOUND_METHOD called_withr)r r rrr s rrBaseSpyOperation._on_spy_callNs{.hh== ==C33 3''ab[[U] 5 Xlg)aInitialize the operation. By default, this takes a list of configurations for matching calls, which the subclass will use to validate and handle a call. The calls are a list of dictionaries with the following keys: ``args`` (:py:class:`tuple`, optional): Positional arguments for a match. ``kwargs`` (:py:class:`dict`, optional): Keyword arguments for a match. ``call_fake`` (:py:class:`callable`, optional): A function to call when all arguments have matched. This takes precedence over ``call_original``. ``call_original`` (:py:class:`bool`, optional): Whether to call the original function. This is the default if ``call_fake`` is not provided. ``op`` (:py:class:`BaseSpyOperation`, optional): A spy operation to call instead of ``call_fake`` or ``call_original``. Subclasses may define custom keys. Version Changed: 6.1: Added support for ``op``. Args: calls (list of dict): A list of call match configurations. N)superr1__init___callsr calls __class__s rr5!BaseMatchingSpyOperation.__init__xsH &68 rc >[[U] "U40UD6n/nURHLnSU;a2UR 5nUR S5RUSS9US'UR U5 MN X@lU$)aSet up the operation. This invokes the common behavior for setting up a spy operation, and then goes through all registered calls to see if any call-provided operations also need to be set up. Version Added: 6.1 Args: spy (kgb.spies.FunctionSpy): The spy this operation is for. **kwargs (dict): Additional keyword arguments to pass to the parent. Returns: callable: The fake function to set up with the spy. opT)r call_fake)r4r1r!r6copypopappend)r rrresult new_callscallr9s rr!BaseMatchingSpyOperation.setups*/[[U] U5 g)aInitialize the operation. This takes a list of configurations for matching calls, which can be called in any order. those calls are expected. The calls are a list of dictionaries with the following keys: ``args`` (:py:class:`tuple`, optional): Positional arguments for a match. ``kwargs`` (:py:class:`dict`, optional): Keyword arguments for a match. ``call_fake`` (:py:class:`callable`, optional): A function to call when all arguments have matched. This takes precedence over ``call_original``. ``call_original`` (:py:class:`bool`, optional): Whether to call the original function. This is the default if ``call_fake`` is not provided. Args: calls (list of dict): A list of call match configurations. N)r4rVr5r7s rr5SpyOpMatchAny.__init__Ys6 mT+E2rc URH>nUR"URSS50URS05D6(dM<Us $ [SSURR 0-5e)aReturn a call match configuration for a call. This will check if there are any call match configurations provided during initialization that match the call. Args: spy_call (kgb.calls.SpyCall): The call to return a match for. Returns: dict: The call match configuration. Raises: kgb.errors.UnexpectedCallError: A call match configuration could not be found. Details should be in the error message. r r/rz3%(spy)s was not called with any expected arguments.r)r6r'rKrr func_name)r r rLs rrF#SpyOpMatchAny.get_call_match_configvs&"& ##%6%:%:62%FK&7&;&;Hb&IKK(("- " Atxx))  rr/ r)r*r+r,r-r5rFr.rSrTs@rrVrV:s<3:rrVc2^\rSrSrSrU4SjrSrSrU=r$)SpyOpMatchInOrderiaYA operation for handling expected calls in a given order. This is used to list the calls (specifying positional and keyword arguments) that are expected to be made, in the order they should be made, raising an error if too many calls were made or a call didn't match the expected arguments. Each of those expected sets of arguments can optionally result in a call to a fake function or the original function. This can be specified per set of arguments. Example: spy_on(lockbox.enter_code, op=SpyOpMatchInOrder([ { 'args': (1, 2, 3, 4, 5, 6), 'call_original': False, }, { 'args': (9, 0, 2, 1, 0, 0), 'call_fake': _start_countdown, }, { 'args': (4, 8, 15, 16, 23, 42), 'kwargs': { 'secret_button_pushed': True, }, 'call_original': True, }, { 'args': (4, 8, 15, 16, 23, 42), 'kwargs': { 'secret_button_pushed': True, }, 'op': SpyOpRaise(Exception('Oh no')), }, ])) c:>[[U] U5 SUlg)aUInitialize the operation. This takes a list of configurations for matching calls, in the order those calls are expected. The calls are a list of dictionaries with the following keys: ``args`` (:py:class:`tuple`, optional): Positional arguments for a match. ``kwargs`` (:py:class:`dict`, optional): Keyword arguments for a match. ``call_fake`` (:py:class:`callable`, optional): A function to call when all arguments have matched. This takes precedence over ``call_original``. ``call_original`` (:py:class:`bool`, optional): Whether to call the original function. This is the default if ``call_fake`` is not provided. ``op`` (:py:class:`BaseSpyOperation`, optional): A spy operation to call instead of ``call_fake`` or ``call_original``. Args: calls (list of dict): A list of call match configurations. rN)r4r^r5_nextr7s rr5SpyOpMatchInOrder.__init__s< /6 rc URnURUnU=RS- slU$![a> [S[ UR5UUS-UR R S.-5ef=f)aReturn a call match configuration for a call. This will check if the spy call matches the next call match configuration in the list provided by the consumer. Args: spy_call (kgb.calls.SpyCall): The call to return a match for. Returns: dict: The call match configuration. Raises: kgb.errors.UnexpectedCallError: Too many calls were made to the function. zy%(spy)s was called %(num_calls)s time(s), but only %(expected_calls)s call(s) were expected. Latest call: %(latest_call)sr$)expected_calls latest_call num_callsr)r`r6 IndexErrorrlenrrZ)r r irLs rrF'SpyOpMatchInOrder.get_call_match_configs$ JJ  $ A  a    %"'*$++&6#+!"Q88--    s 4AA<)r`r\rTs@rr^r^s$L D$!$!rr^c$\rSrSrSrSrSrSrg) SpyOpRaiseizAn operation for raising an exception. This is used to simulate a failure of some sort in a function or method. Example: spy_on(pen.emit_poison, op=SpyOpRaise(PoisonEmptyError())) cXlg)z{Initialize the operation. Args: exc (Exception): The exception instance to raise when the function is called. Nexc)r rns rr5SpyOpRaise.__init__s rcURe)aJHandle a call to this operation. This will raise the exception provided to the operation. Args: *args (tuple, ignored): Positional arguments passed into the call. **kwargs (tuple, ignored): Keyword arguments passed into the call. Raises: Exception: The exception provided to the operation. rmr r rs rrSpyOpRaise.handle_calls hhrrmNr)r*r+r,r-r5rr.r/rrrkrksrrkc,^\rSrSrSrU4SjrSrU=r$)SpyOpRaiseInOrderi*aLAn operation for raising exceptions in the order of calls. This is similar to :py:class:`SpyOpRaise`, but will raise a different exception for each call, based on a provided list. Example: spy_on(our_agent.get_identities, op=SpyOpRaiseInOrder([ PoisonEmptyError(), Kaboom(), MissingPenError(), ])) c n>[[U] UVs/sHnS[U50PM sn5 gs snf)zInitialize the operation. Args: exceptions (list of Exception): The list of exceptions, one for each function call. r<N)r4rur5rk)r exceptionsrnr9s rr5SpyOpRaiseInOrder.__init__8sF /" 1 "jo " 1  1 2r/r)r*r+r,r-r5r.rSrTs@rruru*    rruc$\rSrSrSrSrSrSrg) SpyOpReturniGzAn operation for returning a value. This is used to simulate a simple result from a function call without having to override the method or provide a lambda. Example: spy_on(our_agent.get_identity, op=SpyOpReturn('nobody...')) cXlg)zuInitialize the operation. Args: return_value (object): The value to return when the function is called. N return_value)r rs rr5SpyOpReturn.__init__Qs )rcUR$)aDHandle a call to this operation. This will return the value provided to the operation. Args: *args (tuple, ignored): Positional arguments passed into the call. **kwargs (tuple, ignored): Keyword arguments passed into the call. Returns: object: The return value provided to the operation. rrqs rrSpyOpReturn.handle_callZs    rrNrsr/rrr}r}Gs)!rr}c,^\rSrSrSrU4SjrSrU=r$)SpyOpReturnInOrderima2An operation for returning a value. This is similar to :py:class:`SpyOpReturn`, but will return a different value for each call, based on a provided list. Example: spy_on(our_agent.get_identities, op=SpyOpReturnInOrder([ 'nobody...', 'who?', 'never heard of them...', ])) c n>[[U] UVs/sHnS[U50PM sn5 gs snf)zsInitialize the operation. Args: return_values (list): The list of values, one for each function call. r<N)r4rr5r})r return_valuesvaluer9s rr5SpyOpReturnInOrder.__init__{sG  $0' 2 'k%( ' 2  2 ryr/rzrTs@rrrmr{rrN)r- __future__r kgb.errorsrobjectrr1rVr^rkrur}rr/rrrs.'*e;ve;PG/GTX,Xvm!0m!`"!"J ) :#!"#!L * r