o h3@sdZddlmZddlmZddlmZddlmZddlmZddl Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZerPddlmZddlZddlmZddlmZddlmZddlmZedZed2ddZeddd3ddZed4d$dZ d5d6d'dZe d7ddd8d+d,Zed9d-d,Ze fddd:d/d,ZGd0ddej!Z"eGd1d*d*e"Z#dS);z/Record warnings during test function execution.) annotations)Callable) Generator)IteratorpformatN) TracebackType)Any)final)overload) TYPE_CHECKING)TypeVar)Self)check_ispytest)fixture)Exit)failTreturnGenerator[WarningsRecorder]ccsFtdd}|td|VWddS1swYdS)zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. See :ref:`warnings` for information on warning categories. T _ispytestdefaultN)WarningsRecorderwarnings simplefilter)wrecrP/var/www/html/openai_agents/venv/lib/python3.10/site-packages/_pytest/recwarn.pyrecwarn!s   "r.matchr!str | re.Pattern[str] | NonercCdSNrr rrrdeprecated_call-sr%funcCallable[..., T]argsr kwargscOr#r$r)r&r(r)rrrr%3sCallable[..., Any] | NoneWarningsRecorder | AnycOs4d}|dur |g|R}ttttfg|Ri|S)aAssert that code produces a ``DeprecationWarning`` or ``PendingDeprecationWarning`` or ``FutureWarning``. This function can be used as a context manager:: >>> import warnings >>> def api_call_v2(): ... warnings.warn('use v3 of this api', DeprecationWarning) ... return 200 >>> import pytest >>> with pytest.deprecated_call(): ... assert api_call_v2() == 200 It can also be used by passing a function and ``*args`` and ``**kwargs``, in which case it will ensure calling ``func(*args, **kwargs)`` produces one of the warnings types above. The return value is the return value of the function. In the context manager form you may use the keyword argument ``match`` to assert that the warning matches a text or regex. The context manager produces a list of :class:`warnings.WarningMessage` objects, one for each warning raised. TN)warnsDeprecationWarningPendingDeprecationWarning FutureWarning)r&r(r)__tracebackhide__rrrr%7s expected_warning)type[Warning] | tuple[type[Warning], ...]WarningsCheckercCr#r$r)r1r!rrrr,Ysr,cOr#r$r)r1r&r(r)rrrr,asWarningsChecker | AnycOsd}|s|rdt|}td|dt||ddS|d}t|s0t|dt|dt|dd ||d d i|Wd S1sLwYd S) aAssert that code raises a particular class of warning. Specifically, the parameter ``expected_warning`` can be a warning class or tuple of warning classes, and the code inside the ``with`` block must issue at least one warning of that class or classes. This helper produces a list of :class:`warnings.WarningMessage` objects, one for each warning emitted (regardless of whether it is an ``expected_warning`` or not). Since pytest 8.0, unmatched warnings are also re-emitted when the context closes. This function can be used as a context manager:: >>> import pytest >>> with pytest.warns(RuntimeWarning): ... warnings.warn("my warning", RuntimeWarning) In the context manager form you may use the keyword argument ``match`` to assert that the warning matches a text or regex:: >>> with pytest.warns(UserWarning, match='must be 0 or None'): ... warnings.warn("value must be 0 or None", UserWarning) >>> with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("value must be 42", UserWarning) >>> with pytest.warns(UserWarning): # catch re-emitted warning ... with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("this is not here", UserWarning) Traceback (most recent call last): ... Failed: DID NOT WARN. No warnings of type ...UserWarning... were emitted... **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise a warning and others do not. This could be achieved in the same way as with exceptions, see :ref:`parametrizing_conditional_raising` for an example. Tz, z5Unexpected keyword arguments passed to pytest.warns: z" Use context-manager form instead?) match_exprrrz object (type: z) must be callablerN)joinsorted TypeErrorr3callabletype)r1r!r(r)r0argnamesr&rrrr,js/ $cseZdZdZddd(fdd Zed)d d Zd*ddZd+ddZd,ddZ e fd-ddZ d.ddZ d/fdd Z d0fd&d' ZZS)1raFA context manager to record raised warnings. Each recorded warning is an instance of :class:`warnings.WarningMessage`. Adapted from `warnings.catch_warnings`. .. note:: ``DeprecationWarning`` and ``PendingDeprecationWarning`` are treated differently; see :ref:`ensuring_function_triggers`. FrrboolrNonecs&t|tjddd|_g|_dS)NT)recordF)rsuper__init___entered_list)selfr __class__rrrAs zWarningsRecorder.__init__list[warnings.WarningMessage]cCs|jS)zThe list of recorded warnings.rCrDrrrlistszWarningsRecorder.listiintwarnings.WarningMessagecCs |j|S)z Get a recorded warning by index.rH)rDrKrrr __getitem__ zWarningsRecorder.__getitem__!Iterator[warnings.WarningMessage]cC t|jS)z&Iterate through the recorded warnings.)iterrCrIrrr__iter__rOzWarningsRecorder.__iter__cCrQ)z The number of recorded warnings.)lenrCrIrrr__len__rOzWarningsRecorder.__len__cls type[Warning]cCsd}t|jD]'\}}|j|kr|j|St|j|r.|dus,t|j|j|js.|}q|dur9|j|Sd}t|d)zPop the first recorded warning which is an instance of ``cls``, but not an instance of a child class of any other match. Raises ``AssertionError`` if there is no match. NTz not found in warning list) enumeraterCcategorypop issubclassAssertionError)rDrVbest_idxrKwr0rrrrZs   zWarningsRecorder.popcCsg|jdd<dS)z$Clear the list of recorded warnings.NrHrIrrrclearszWarningsRecorder.clearrcsD|jr d}td|dt}|dusJ||_td|S)NTz Cannot enter z twicealways)rB RuntimeErrorr@ __enter__rCrr)rDr0rCrErrrbs   zWarningsRecorder.__enter__exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | Nonecs4|js d}td|dt|||d|_dS)NTz Cannot exit z without entering firstF)rBrar@__exit__)rDrcrergr0rErrris  zWarningsRecorder.__exit__)rr=rr>)rrG)rKrLrrM)rrP)rrL)rVrWrrM)rr>)rrrcrdrerfrgrhrr>)__name__ __module__ __qualname____doc__rApropertyrJrNrSrUWarningrZr_rbri __classcell__rrrErrs       csBeZdZedfdddfd d ZdddZdfdd ZZS)r3NFrr1r2r5r"rr=rr>cst|tjddd}t|tr'|D]}t|ts#t|t|q|}nt|tr5t|tr5|f}nt|t|||_ ||_ dS)NTrz/exceptions must be derived from Warning, not %s) rr@rA isinstancetupler[rpr9r;r1r5)rDr1r5rmsgexcexpected_warning_tuprErrrAs     zWarningsChecker.__init__warningrMcCs>|jdusJt|j|jot|jdupt|jt|jSr$) r1r[rYr=r5researchstrmessage)rDrwrrrmatchesszWarningsChecker.matchesrcrdrerfrgrhcst|||d}|durt|trt|trdSdfdd }z~tfddDs;tdjd |d ntfd dDsWtdjd jd |d WD]} |srt j |j |j |j|j|j|jdqZD](}t|j turqu|j jsqu|j jd}t|trqutd|dt|jddSD]} |st j |j |j |j|j|j|jdqD](}t|j turq|j jsq|j jd}t|trqtd|dt|jdw)NTrrzcstddDddS)NcSsg|]}|jqSr)r{).0r?rrr 9sz?WarningsChecker.__exit__..found_str..)indentrrrIrr found_str8sz+WarningsChecker.__exit__..found_strc3s|] }t|jjVqdSr$)r[rYr1r}r^rIrr <sz+WarningsChecker.__exit__..z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3s|]}|VqdSr$)r|rrIrrrAsz* matching the regex were emitted. Regex: z Emitted warnings: )r{rYfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))rrz)r@rirr Exceptionranyrr1r5r|r warn_explicitr{rYrrrlrr; UserWarningr(rzr9rk)rDrcrergr0rr^rtrErIrri#s        zWarningsChecker.__exit__)r1r2r5r"rr=rr>)rwrMrr=rj)rkrlrmrprAr|rirqrrrErr3s )rr)r!r"rr)r&r'r(r r)r rrr$)r&r*r(r r)r rr+).)r1r2r!r"rr3) r1r2r&r'r(r r)r rr) r1r2r(r r!r"r)r rr4)$rn __future__rcollections.abcrrrpprintrrxtypesrtypingr r r r r typing_extensionsrr_pytest.deprecatedr_pytest.fixturesr_pytest.outcomesrrrrr%r,rpcatch_warningsrr3rrrrsX                    "  @W