a *j3@sdZddlmZddlmZddlmZddlmZddlmZddl Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZerddlmZddlZddlmZddlmZddlmZddlmZedZeddddZedddddddZedd d dd!d"dZd2d#d d d$d!d%dZed3ddd&dd'd(d)d*Zed&dd d dd+d,d*Ze fddd&d dd d-d.d/d*ZGd0ddej!Z"eGd1d'd'e"Z#dS)4z/Record warnings during test function execution.) annotations)Callable) Generator)IteratorpformatN) TracebackType)Any)final)overload) TYPE_CHECKING)TypeVar)Self)check_ispytest)fixture)Exit)failTzGenerator[WarningsRecorder]returnccsBtdd}| td|VWdn1s40YdS)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)Zwrecr5E:\soccer\ml_env\Lib\site-packages\_pytest/recwarn.pyrecwarn!s  r.matchstr | re.Pattern[str] | Noner)r rcCsdSNrrrrrdeprecated_call-sr#zCallable[..., T]r )funcargskwargsrcOsdSr"r)r$r%r&rrrr#3szCallable[..., Any] | NonezWarningsRecorder | 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 )type[Warning] | tuple[type[Warning], ...]WarningsChecker)expected_warningr rcCsdSr"r)r.r rrrr'Ysr')r.r$r%r&rcOsdSr"r)r.r$r%r&rrrr'aszWarningsChecker | Any)r.r%r r&rcOsd}|s8|r*dt|}td|dt||ddS|d}t|s`t|dt|dt|dd &||d d i|Wd S1s0Yd 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 TypeErrorr-callabletype)r.r r%r&r+argnamesr$rrrr'js/ cseZdZdZdddddfddZed d d d Zd ddddZdd ddZd d ddZ e fdddddZ dd ddZ dd fdd Z d d!d"dd#fd$d% ZZS)&raFA 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`. FrboolNone)rrcs&t|tjddd|_g|_dS)NT)recordF)rsuper__init___entered_list)selfr __class__rrr;szWarningsRecorder.__init__zlist[warnings.WarningMessage]rcCs|jS)zThe list of recorded warnings.r=r>rrrlistszWarningsRecorder.listintwarnings.WarningMessage)ircCs |j|S)z Get a recorded warning by index.rA)r>rFrrr __getitem__szWarningsRecorder.__getitem__z!Iterator[warnings.WarningMessage]cCs t|jS)z&Iterate through the recorded warnings.)iterr=rBrrr__iter__szWarningsRecorder.__iter__cCs t|jS)z The number of recorded warnings.)lenr=rBrrr__len__szWarningsRecorder.__len__z type[Warning])clsrcCsd}t|jD]N\}}|j|kr0|j|St|j|r|dusXt|j|j|js|}q|durr|j|Sd}t|ddS)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) enumerater=categorypop issubclassAssertionError)r>rLZbest_idxrFwr+rrrrOs   zWarningsRecorder.popcCsg|jdd<dS)z$Clear the list of recorded warnings.NrArBrrrclearszWarningsRecorder.clearrcsD|jrd}td|dt}|dus0J||_td|S)NTz Cannot enter z twicealways)r< RuntimeErrorr: __enter__r=rr)r>r+r=r?rrrVs   zWarningsRecorder.__enter__type[BaseException] | NoneBaseException | NoneTracebackType | Noneexc_typeexc_valexc_tbrcs4|jsd}td|dt|||d|_dS)NTz Cannot exit z without entering firstF)r<rUr:__exit__)r>r[r\r]r+r?rrr^s zWarningsRecorder.__exit__)__name__ __module__ __qualname____doc__r;propertyrCrGrIrKWarningrOrSrVr^ __classcell__rrr?rrs  cs\eZdZedfdddddddfd d Zd dd d dZdddddfdd ZZS)r-NFrr,r!r7r8)r.r/rrcst|tjddd}t|trN|D]}t|ts(t|t|q(|}n,t|trjt|trj|f}nt|t|||_ ||_ dS)NTrz/exceptions must be derived from Warning, not %s) rr:r; isinstancetuplerPrdr3r5r.r/)r>r.r/rmsgexcZexpected_warning_tupr?rrr;s   zWarningsChecker.__init__rE)warningrcCs>|jdusJt|j|jorjrrrmatchesszWarningsChecker.matchesrWrXrYrZcst|||d}|dur4t|tr0t|tr4dSddfdd }ztfddDs|tdjd |d n8tfd dDstdjd jd |d WD]0} |st j |j |j |j|j|j|jdqD]X}t|j turq|j jsq|j jd}t|tr,qtd|dt|jdqnD]4} |sPt j |j |j |j|j|j|jdqPD]`}t|j turq|j jsq|j jd}t|tr̐qtd|dt|jdq0dS)NTrmrcstddDddS)NcSsg|] }|jqSr)rn).0r9rrr 9z?WarningsChecker.__exit__..found_str..)indentrrrBrr found_str8sz+WarningsChecker.__exit__..found_strc3s|]}t|jjVqdSr")rPrNr.rprRrBrr <rrz+WarningsChecker.__exit__..z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3s|]}|VqdSr")rorvrBrrrwArrz* matching the regex were emitted. Regex: z Emitted warnings: )rnrNfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))r:r^rf Exceptionranyrr.r/ror warn_explicitrnrNryrzr`r|r5 UserWarningr%rmr3r_)r>r[r\r]r+rurRrhr?rBrr^#s           zWarningsChecker.__exit__)r_r`rardr;ror^rerrr?rr-s)N).)$rb __future__rcollections.abcrrrpprintrrktypesrtypingr r r r r Ztyping_extensionsrrZ_pytest.deprecatedrZ_pytest.fixturesrZ_pytest.outcomesrrrrr#r'rdcatch_warningsrr-rrrrsV                 " @W