ijSrSSKJr SSKJr SSKJr SSKJr SSK J r J r SSK J r "SS \5rg ) zA spy agency to manage spies.)unicode_literals)pformat) safe_repr) _UNSET_ARG) FunctionSpySpyCall)format_spy_kwargsc6^\rSrSrSrU4SjrU4SjrSr\4Sjr Sr Sr S r S r S rS rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrS"SjrS"Sjr S"Sjr!S"Sjr"S#S jr#\ r$\r%\r&\r'\r(\r)\r*\r+\r,\r-\r.\r/\r0\r1\r2S!r3U=r4$)$ SpyAgency aManages spies. A SpyAgency can be instantiated or mixed into a :py:class:`unittest.TestCase` in order to provide spies. Every spy created through this agency will be tracked, and can be later be removed (individually or at once). Version Changed: 7.0: Added ``assert_`` versions of all the assertion methods (e.g., ``assert_spy_called_with`` as an alias of ``assertSpyCalledWith``. Attributes: spies (set of kgb.spies.FunctionSpy): All spies currently registered with this agency. cL>[[U] "U0UD6 [5Ulg)aInitialize the spy agency. Args: *args (tuple): Positional arguments to pass on to any other class (if using this as a mixin). **kwargs (dict): Keyword arguments to pass on to any other class (if using this as a mixin). N)superr __init__setspies)selfargskwargs __class__s I/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/kgb/agency.pyrSpyAgency.__init__ s" i'88U cJ>[[U] 5 UR5 g)zTear down a test suite. This is used when SpyAgency is mixed into a TestCase. It will automatically remove all spies when tearing down. N)rr tearDown unspy_all)rrs rrSpyAgency.tearDown0s i') rcZ[U/UQ70UD6nURRU5 U$)aSpy on a function. By default, the spy 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``. See :py:class:`~kgb.spies.FunctionSpy` for more details on arguments. Args: *args (tuple): Positional arguments to pass to :py:class:`~kgb.spies.FunctionSpy`. **kwargs (dict): Keyword arguments to pass to :py:class:`~kgb.spies.FunctionSpy`. Returns: kgb.spies.FunctionSpy: The resulting spy. )rradd)rrrspys rspy_onSpyAgency.spy_on9s-6$000 s rc^^^UUU4SjnU$)aDecorate a function that should be a spy for another function. This is a convenience over declaring a function and using :py:meth:`spy_on` with ``call_fake=``. It's used to quickly and easily create a fake function spy for another function. Version Added: 6.0 Args: func (callable): The function or method to spy on. 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. Example: @self.spy_for(get_doomsday): def _fake_get_doomsday(): return datetime(year=2038, month=12, day=5, hour=1, minute=2, second=3) c*>TRTTUS9 U$)N)owner call_fake)r )r%funcr$rs r_wrap SpyAgency.spy_for.._wrapws$ KK#"+  - r)rr&r$r's``` rspy_forSpyAgency.spy_forXs>  rcURnX R;deUR 5 g![a [SU-5ef=f)zStop spying on a function. Args: func (callable): The function to stop spying on. Raises: ValueError: The provided function was not spied on. "Function %r has not been spied on.N)rAttributeError ValueErrorrunspy)rr&rs rr0SpyAgency.unspysP J((Cjj     JADHI I Js 0A c|URHnURSS9 M URR5 g)z4Stop spying on all functions tracked by this agency.F) unregisterN)rr0clearrrs rrSpyAgency.unspy_alls0::C III ' rcTUR$![a [SU-5ef=f)aiReturn the spy for a function. This method is a helper to prevent type checkers from complaining when accessing data about a spy. Version Added: 7.3 Args: func (callable): The function to return the spy for. Returns: kgb.spies.FunctionSpy: The function's spy. Raises: ValueError: The provided function was not spied on. r-)rr.r/)rr&s rget_spySpyAgency.get_spys3* J88O JADHI I Js 'c[US5(d:[U[5(d$URSUR U5-5 ggg)aAssert that a function has a spy. This also accepts a spy as an argument, which will always return ``True``. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. Raises: AssertionError: The function did not have a spy. rz%s has not been spied on.N)hasattr isinstancer_kgb_assert_fail_format_spy_or_callr5s r assertHasSpySpyAgency.assertHasSpysLsE"":c;+G+G  ! !"=$($<$r5s rassertSpyCalledSpyAgency.assertSpyCalledsD #zz  ! !"6$($<$_format_spy_calls_format_spy_call_args)rr call_counts rassertSpyCalledOnceSpyAgency.assertSpyCalledOncesq S!^ >  ! !,,S1**30J0JK  rc8URU5 UR(ax[UR5nUS:XaSUR U5-nOSUR U5U4-nUR U<SUR XR5<35 gg)zAssert that a function has not been called. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. Raises: AssertionError: The function was called. rFz%s was called 1 time:z%s was called %d times: N)r?rBrGrHr>r=rIrJ)rrrKmsgs rassertSpyNotCalledSpyAgency.assertSpyNotCalleds # ::SYYJQ+..s34 .//4jAB  ! ! **30J0JK   rcURU5 [UR5nX2:wa2US:XaSnOSnURUUR U5UU4-5 gg)aAssert that a function was called the given number of times. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. count (int): The number of times the function is expected to have been called. Raises: AssertionError: The function was not called the specified number of times. rFz%s was called %d time, not %d.z%s was called %d times, not %d.N)r?rGrHr=r>)rrcountrKrPs rassertSpyCallCountSpyAgency.assertSpyCallCountsi" #^  Q67  ! !##'#;#;C#@#-#(#*#* + rc [U[5(aURU5 UR"U0UD6(d[U[5(aRUR SUR U5<S[U5<S[U5<SURU5<35 gUR SUR U5<S[U5<S[U5<SURUUR5<35 gg) a@Assert that a function was called with the given arguments. If a spy is provided, all calls will be checked for a match. This will imply :py:meth:`assertHasSpy`. Args: spy_or_call (callable or kgb.spies.FunctionSpy): The function, spy, or call to check. *expected_args (tuple): Positional arguments expected to be provided in any of the calls. **expected_kwargs (dict): Keyword arguments expected to be provided in any of the calls. Raises: AssertionError: The function was not called with the provided arguments. This call to  was not passed args= , kwargs=. It was called with: No call to  was passed args='. The following calls were recorded: N) r<rrC called_withrr=r>rr rJrIr spy_or_call expected_argsexpected_kwargss rassertSpyCalledWithSpyAgency.assertSpyCalledWith>s. k; / /   -&& II+w//%%00=!-0)/:22;?  %%00=!-0)/:..' 668  Jrc URU5 UR"U0UD6(d[U[5(aRUR SUR U5<S[ U5<S[U5<SURU5<35 gUR SUR U5<S[ U5<S[U5<SURUUR5<35 gg) a@Assert that a function was called once with the given arguments. This will fail if there was more than one call to the function. This will imply :py:meth:`assertSpyCalledOnce`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. *expected_args (tuple): Positional arguments expected to be provided in any of the calls. **expected_kwargs (dict): Keyword arguments expected to be provided in any of the calls. Raises: AssertionError: The function was not called with the provided arguments. rXrYrZr[r\r]r^N) rLr_r<rr=r>rr rJrIrrrbrcs rassertSpyCalledOnceWith!SpyAgency.assertSpyCalledOnceWithvs,   % AA#w''%%005!-0)/:2237  %%005!-0)/:.. 668  Brc [U[5(aURU5 UR"U0UD6(a[U[5(a@UR SUR U5<S[U5<S[U5<S35 gUR SUR U5<S[U5<S[U5<SURUUR5<35 gg)aPAssert that a function was not called with the given arguments. If a spy is provided, all calls will be checked for a match. This will imply :py:meth:`assertHasSpy`. Args: spy_or_call (callable or kgb.spies.FunctionSpy): The function, spy, or call to check. *expected_args (tuple): Positional arguments not expected to be provided in any of the calls. **expected_kwargs (dict): Keyword arguments not expected to be provided in any of the calls. Raises: AssertionError: The function was called with the provided arguments. rXz was unexpectedly passed args=rZ.z A call to r^N) r<rrCr_rr=r>rr rIrJr`s rassertSpyNotCalledWith SpyAgency.assertSpyNotCalledWiths0 k; / /   -  " "M E_ E+w//%%00=!-0)/: %%00=!-0)/:..' 668  Frc  URU5 UR"U0UD6(d\URSURU5<S[ U5<S[ U5<SUR UR5<35 gg)aAssert that a function was last called with the given arguments. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. *expected_args (tuple): Positional arguments expected to be provided in the last call. **expected_kwargs (dict): Keyword arguments expected to be provided in the last call. Raises: AssertionError: The function was not called last with the provided arguments. The last call to rYrZz. It was last called with: N)rClast_called_withr=r>rr rJ last_callrgs rassertSpyLastCalledWith!SpyAgency.assertSpyLastCalledWithsp& S!##]FoF  ! !,,S1m,%o6..s}}=  Grc [U[5(aURU5 URU5(d[U[5(aEUR SUR U5<S[U5<SURU5<35 gUR SUR U5<S[U5<SURUUR5<35 gg)aAssert that a function call returned the given value. If a spy is provided, all calls will be checked for a match. This will imply :py:meth:`assertHasSpy`. Args: spy_or_call (callable or kgb.spies.FunctionSpy or kgb.spies.SpyCall): The function, spy, or call to check. return_value (object or type): The value expected to be returned by any of the calls. Raises: AssertionError: The function never returned the provided value. rX did not return z. It returned: r\z returned z-. The following values have been returned: N) r<rrCreturnedrr=r>r_format_spy_call_returnedrI)rra return_values rassertSpyReturnedSpyAgency.assertSpyReturneds& k; / /   -##L11+w//%%00=!,/66{C  %%00=!,/..' ::<  2rc URU5 URU5(dOURSURU5<S[ U5<SUR UR 5<35 gg)aAssert that the last function call returned the given value. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. return_value (object or type): The value expected to be returned by the last call. Raises: AssertionError: The function's last call did not return the provided value. roruz. It last returned: N)rC last_returnedr=r>rrwrq)rrrxs rassertSpyLastReturnedSpyAgency.assertSpyLastReturned7se S!  ..  ! !,,S1l+223==A  /rc [U[5(aURU5 URU5(Gd%[U[5(axUR bGUR SURU5<SUR<SURU5<S35 gUR SURU5-5 g[SUR55nU(aQUR SURU5<S UR<S URUUR5<35 gUR S URU5-5 gg) aAssert that a function call raised the given exception type. If a spy is provided, all calls will be checked for a match. This will imply :py:meth:`assertHasSpy`. Args: spy_or_call (callable or kgb.spies.FunctionSpy or kgb.spies.SpyCall): The function, spy, or call to check. exception_cls (type): The exception type expected to be raised by one of the calls. Raises: AssertionError: The function never raised the provided exception type. NrX did not raise z . It raised rk+This call to %s did not raise an exception.c3># UHnURSLv M g7fN exception.0calls r ,SpyAgency.assertSpyRaised..{ ! 1NN$. 1r\ raised /. The following exceptions have been raised: "No call to %s raised an exception.) r<rrCraisedrrr=r>__name___format_spy_call_raisedanyrHrI)rra exception_cls has_raiseds rassertSpyRaisedSpyAgency.assertSpyRaisedVsC& k; / /   -!!-00+w//((4))!44[A)22 88E ))E22;?@A!! + 1 1! )) !44[A)22 22 + $ < <>  ))<22;?@AE1rc jURU5 URU5(dURRbQUR SUR U5<SUR <SURUR5<S35 gUR SUR U5-5 gg)aAssert that the last function call raised the given exception type. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. exception_cls (type): The exception type expected to be raised by the last call. Raises: AssertionError: The last function call did not raise the provided exception type. Nrorz. It last raised rk/The last call to %s did not raise an exception.)rC last_raisedrqrr=r>rr)rrrs rassertSpyLastRaisedSpyAgency.assertSpyLastRaiseds" S!}--}}&&2%%005%..44S]]C %%E..s345.rc [U[5(aURU5 URX#5(Gd,[U[5(a{UR bJUR SURU5<SUR<SU<SURU5<35 gUR SURU5-5 g[SUR55nU(aUUR SURU5<S UR<SU<S URUUR5<35 gUR S URU5-5 gg) amAssert that a function call raised the given exception/message. If a spy is provided, all calls will be checked for a match. This will imply :py:meth:`assertHasSpy`. Args: spy_or_call (callable or kgb.spies.FunctionSpy or kgb.spies.SpyCall): The function, spy, or call to check. exception_cls (type): The exception type expected to be raised by one of the calls. message (bytes or unicode): The expected message in a matching extension. Raises: AssertionError: The function never raised the provided exception type with the expected message. NrXr with message z. It raised: rc3># UHnURSLv M g7frrrs rr3SpyAgency.assertSpyRaisedMessage..rrr\rrr) r<rrCraised_with_messagerrr=r>r$_format_spy_call_raised_with_messagerrHrI)rrarmessagers rassertSpyRaisedMessage SpyAgency.assertSpyRaisedMessagesN. k; / /   -..}FF+w//((4))!44[A)22# EE +-  ))E22;?@A!! + 1 1! ))!44[A)22# 22 + $ I IK  ))<22;?@AUGrc pURU5 URX#5(dURRbTUR SUR U5<SUR <SU<SURUR5<35 gUR SUR U5-5 gg)aAssert that the function last raised the given exception/message. This will imply :py:meth:`assertHasSpy`. Args: spy (callable or kgb.spies.FunctionSpy): The function or spy to check. exception_cls (type): The exception type expected to be raised by the last call. message (bytes or unicode): The expected message in the matching extension. Raises: AssertionError: The last function call did not raise the provided exception type with the expected message. Nrorrz. It last raised: r)rClast_raised_with_messagerqrr=r>rr)rrrrs rassertSpyLastRaisedMessage$SpyAgency.assertSpyLastRaisedMessages( S!++MCC}}&&2%%005%..AAMM+  %%E..s345!Drc[US5(a#[US5(aURU5 g[U5e)aGRaise an assertion failure. If this class is mixed into a unit test suite, this will call the main :py:meth:`unittest.TestCase.fail` method. Otherwise, it will simply raise an :py:exc:`AssertionError`. Args: msg (unicode): The assertion message. Raises: AssertionError: The assertion error to raise. failfailureExceptionN)r;rAssertionError)rrPs rr=SpyAgency._kgb_assert_fail&s4 4 WT3E%F%F IIcN % %rc [U[5(a URnO.[U[5(aURRnOUnUR n[U[ 5(aURS5nU$)zFormat a spy or call for output in an assertion message. Args: spy_or_call (callable or kgb.spies.FunctionSpy or kgb.spies.SpyCall): The spy or call to format. Returns: unicode: The formatted name of the function. zutf-8)r<r orig_funcrrrbytesdecode)rrarnames rr>SpyAgency._format_spy_or_call;sf k; / /''C  W - -//++CC|| dE " ";;w'D rc`^SRU4Sj[UR555$)aFormat a list of calls for a spy. Args: spy (callable or kgb.spies.FunctionSpy): The spy to format. formatter (callable): A formatting function used for each recorded call. Returns: unicode: The formatted output of the calls. rOc3@># UHupSUT"USS94-v M g7f)z Call %d: %sindentNr))rir formatters rr.SpyAgency._format_spy_calls..cs+ / a4!:; ;/s)join enumeraterH)rrrs `rrISpyAgency._format_spy_callsUs,{{ $SYY/   rcxURURSUS9<SURURSUS9<3$)a Format a call's arguments. Args: call (kgb.spies.SpyCall): The call containing arguments to format. indent (int, optional): The indentation level for any output. Returns: unicode: The formatted output of the arguments for the call. zargs=prefixr zkwargs=)_format_spy_linesrrrrrs rrJSpyAgency._format_spy_call_argshsN  " "499*1*0 # 2  " "4;;*3*0 # 2   rc6URURUS9$)aFormat the return value from a call. Args: call (kgb.spies.SpyCall): The call containing a return value to format. indent (int, optional): The indentation level for any output. Returns: unicode: The formatted return value from the call. r)rrxrs rrw#SpyAgency._format_spy_call_returneds'%%d&7&7-3&5 5rc`URURRRUSS9$)a"Format the exception type raised by a call. Args: call (kgb.spies.SpyCall): The call that raised an exception to format. indent (int, optional): The indentation level for any output. Returns: unicode: The formatted name of the exception raised by a call. F)r format_data)rrrrrs rr!SpyAgency._format_spy_call_raiseds4%%dnn&>&>&G&G-327&9 9rcURURRRSUSS9<SUR[ UR5SUS9<3$)aKFormat the exception type and message raised by a call. Args: call (kgb.spies.SpyCall): The call that raised an exception to format. indent (int, optional): The indentation level for any output. Returns: unicode: The formatted name of the exception and accompanying message raised by a call. z exception=F)rrrrzmessage=r)rrrrstrrs rr.SpyAgency._format_spy_call_raised_with_messagesb  " "4>>#;#;#D#D*6*0/4 # 6  " "3t~~#6*4*0 # 2   rcSU-nU(a [U5nUR5nU<U<US<3/n[U5S:a0SU[U5--nUUSSVs/sH nU<U<3PM sn- nSRU5$s snf)aFormat a multi-line list of output for an assertion message. Unless otherwise specified, the provided data will be formatted using :py:func:`pprint.pformat`. The first line of data will be prefixed, if a prefix is provided. Subsequent lines be aligned with the contents after the prefix. All line will be indented by the given amount. Args: data (object): The data to format. prefix (unicode, optional): An optional prefix for the first line in the data. indent (int, optional): The indentation level for any output. format_data (bool, optional): Whether to format the provided ``data`` using :py:func:`pprint.pformat`. Returns: unicode: The formatted string for the data.  rrFNr)r splitlinesrGr) rdatarrr indent_str data_lineslineslines rrSpyAgency._format_spy_liness:6\ 4=D__& 'A?@ z?Q V 45J &qrN*D%d+* E yy sB)r)r)rT)5r __module__ __qualname____firstlineno____doc__rrr rr*r0rr8r?rCrLrQrUrdrhrlrrryr}rrrrr=r>rIrJrwrrrassert_has_spyassert_spy_calledassert_spy_called_onceassert_spy_not_calledassert_spy_call_countassert_spy_called_withassert_spy_called_once_withassert_spy_not_called_withassert_spy_last_called_withassert_spy_returnedassert_spy_last_returnedassert_spy_raisedassert_spy_last_raisedassert_spy_raised_messageassert_spy_last_raised_message__static_attributes__ __classcell__)rs@rr r s$ >#-&P(J4C$C&<$L+@6p4l4l!F0d>:Ax 5DFAP(5T&*4 & .5"9$ 2- d"N'0..0"9!7"9+4'0 6%?"rr N)r __future__rpprintr unittest.utilr kgb.signaturer kgb.spiesrr kgb.utilsr objectr r)rrrs*#'#$*'n@n@r