o h*@sdZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZedZede dfddZeddde eeeefddfdd Z ed!e defd"ed#edefd$d Z d.d!e e defd"ed#ededeffd%d Z e d/ddd&eee!eee!dffde eeeefdd'fd(d)Z"ed&eee!eee!dffd!e defd"ed#edef d*d)Z"e!fddd&eee!eee!dffd"ede eeeefd#eded'eff d+d)Z"Gd,ddej#Z$eGd-d'd'e$Z%dS)0z/Record warnings during test function execution.Npformat) TracebackType)Any)Callable) Generator)Iterator)List)Optional)Pattern)Tuple)Type)TypeVar)Union)final)overload)check_ispytest)WARNS_NONE_ARG)fixture)failTreturn)WarningsRecorderNNccsFtdd}|td|VWddS1swYdS)zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. See https://docs.pytest.org/en/latest/how-to/capture-warnings.html for information on warning categories. T _ispytestdefaultN)rwarnings simplefilter)wrecrE/var/www/html/ai/venv/lib/python3.10/site-packages/_pytest/recwarn.pyrecwarns   "r!.matchr#rcCdSNrr"rrr deprecated_call*r&funcargskwargscOr$r%r)r(r)r*rrr r&1r'cOs0d}|dur |f|}tttfg|Ri|S)aAssert that code produces a ``DeprecationWarning`` or ``PendingDeprecationWarning``. 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)r(r)r*__tracebackhide__rrr r&8s expected_warningWarningsCheckercCr$r%r)r/r#rrr r+Xsr+cOr$r%r)r/r(r)r*rrr r+ascOsd}|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 sequence 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 raised (regardless of whether it is an ``expected_warning`` or not). This function can be used as a context manager, which will capture all the raised warnings inside it:: >>> 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, 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 TypeErrorr0callabletype)r/r#r)r*r.argnamesr(rrr r+ks. $cseZdZdZdddeddffddZeded fd d Zd e dd fd dZ de d fddZ de fddZ efdeedd fddZdddZd fdd Zdeeedeedeeddffdd 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`. FrrrNcs&t|tjddd|_g|_dS)NT)recordF)rsuper__init___entered_list)selfr __class__rr r;s zWarningsRecorder.__init__zwarnings.WarningMessagecCs|jS)zThe list of recorded warnings.r=r>rrr listszWarningsRecorder.listicCs |j|S)z Get a recorded warning by index.rA)r>rDrrr __getitem__ zWarningsRecorder.__getitem__cC t|jS)z&Iterate through the recorded warnings.)iterr=rBrrr __iter__rFzWarningsRecorder.__iter__cCrG)z The number of recorded warnings.)lenr=rBrrr __len__rFzWarningsRecorder.__len__clscCsBt|jD]\}}t|j|r|j|Sqd}t|d)z>Pop the first recorded warning, raise exception if not exists.Tz not found in warning list) enumerater= issubclasscategorypopAssertionError)r>rLrDwr.rrr rPs  zWarningsRecorder.popcCsg|jdd<dS)z$Clear the list of recorded warnings.NrArBrrr clearszWarningsRecorder.clearcsD|jr d}td|dt}|dusJ||_td|S)NTz Cannot enter z twicealways)r< RuntimeErrorr: __enter__r=rr)r>r.r=r?rr rVs   zWarningsRecorder.__enter__exc_typeexc_valexc_tbcs4|js d}td|dt|||d|_dS)NTz Cannot exit z without entering firstF)r<rUr:__exit__)r>rWrXrYr.r?rr rZs  zWarningsRecorder.__exit__)rN)rr)__name__ __module__ __qualname____doc__boolr;propertyr rCintrErrIrKWarningr rPrSrVr BaseExceptionrrZ __classcell__rrr?r rs(   c seZdZedfdddeeeeeeedffdeeee efde ddffd d Z d eee d ee d ee ddffdd ZZS)r0NFrr/.r1rrcst|tjddd}|durtjtddd}n+t|tr5|D]}t|t s1t |t |q"|}nt|t r>|f}nt |t |||_ ||_ dS)NTrz/exceptions must be derived from Warning, not %s) stacklevel)rr:r;rwarnr isinstancetuplerNrbr5r7r/r1)r>r/r1rmsgexpected_warning_tupexcr?rr r;s"     zWarningsChecker.__init__rWrXrYcst|||d}fdd}|duro|durq|dursjdurutfddDs=d}tdjd|ddSjdurwD]}t|jjr\t j t |j r\dSqDtdjd jd |dSdSdSdSdSdS) NTcstddDddS)NcSsg|]}|jqSr)message).0r9rrr #sz?WarningsChecker.__exit__..found_str..)indentrrrBrr found_str"sz+WarningsChecker.__exit__..found_strc3s|] }t|jjVqdSr%)rNrOr/)rnrrBrr (sz+WarningsChecker.__exit__..z"DID NOT WARN. No warnings of type z0 were emitted. The list of emitted warnings is: .z* matching the regex were emitted. Regex: z Emitted warnings: ) r:rZr/anyrr1rNrOrecompilesearchstrrm)r>rWrXrYr.rrrsr?rBr rZs<     zWarningsChecker.__exit__)r[r\r]rbr rr r rzr r_r;rcrrZrdrrr?r r0s2 r%).)&r^rwrpprintrtypesrtypingrrrrr r r r r rr_pytest.compatrr_pytest.deprecatedrr_pytest.fixturesr_pytest.outcomesrrr!rzr&rbr+catch_warningsrr0rrrr s                                ?O