F-Ph"RddlmZddlmZddlmZddlZddlmZddlZddlm Z ddl m Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZddl mZddl mZddlZddlmZddlmZddlmZddlmZerKddlmZddlmZddl Z ddl!m"Z"ddl!m#Z#ddl!m$Z$e"dZ%e$de&e&dZ'e$de&e&Z(nddl m$Z$e$de&dZ'e$d e&dZ)e$d!e&"Z*e$d#e&"Z+e$d$e,"Z-e$d%e,"Z.ej/d&kr dd'l0m1Z1dd(l0m2Z2ej3d)j4Z5ed*d*d+dhd4Z6ed*d5did9Z6edjd:Z6edkdAZ6 dldmdDZ6ej,e6_,dndGZ7dodKZ8dpdMZ9dqdPZ:drdVZ;dsdXZe Gd\d]e>e'Z?e Gd^d_e>e1e)Z@e Gd`daZAGdbdcZBdldtdgZCdS)u) annotations)ABC)abstractmethodN)Pattern)indent)Any)cast)final)Generic)get_args) get_origin)Literal)overload) TYPE_CHECKING) ExceptionInfo)stringify_exception)fail) PytestWarning)Callable)Sequence) ParamSpec) TypeGuard)TypeVarPBaseExcT_co_defaultT)bounddefault covariantE)rr)rr BaseExcT_co BaseExcT_1)r BaseExcT_2ExcT_1ExcT_2) )BaseExceptionGroup)ExceptionGroup.matchcheckexpected_exceptiontype[E] | tuple[type[E], ...]r+str | re.Pattern[str] | Noner,Callable[[E], bool]return RaisesExc[E]cdSN)r-r+r,s N/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/_pytest/raises.pyraisesr7Is 3r,str | re.Pattern[str]Callable[[BaseException], bool]RaisesExc[BaseException]cdSr4r5r*s r6r7r7Rs #sr8cdSr4r5r9s r6r7r7[sSVSVr8funcCallable[..., Any]argsrkwargsExceptionInfo[E]cdSr4r5)r-r?rArBs r6r7r7_s sr8$type[E] | tuple[type[E], ...] | None+RaisesExc[BaseException] | ExceptionInfo[E]cd}|sjt|hdz r;d}|dt|z }|dz }t|| t d i|St |fi|S|st d|d|d }t |s"t|d t|d t |5}||d di|dddn #1swxYwY |~S#~wxYw)aAssert that a code block/function call raises an exception type, or one of its subclasses. :param expected_exception: The expected exception type, or a tuple if one of multiple possible exception types are expected. Note that subclasses of the passed exceptions will also match. This is not a required parameter, you may opt to only use ``match`` and/or ``check`` for verifying the raised exception. :kwparam str | re.Pattern[str] | None match: If specified, a string containing a regular expression, or a regular expression object, that is tested against the string representation of the exception and its :pep:`678` `__notes__` using :func:`re.search`. To match a literal string that may contain :ref:`special characters `, the pattern can first be escaped with :func:`re.escape`. (This is only used when ``pytest.raises`` is used as a context manager, and passed through to the function otherwise. When using ``pytest.raises`` as a function, you can use: ``pytest.raises(Exc, func, match="passed on").match("my pattern")``.) :kwparam Callable[[BaseException], bool] check: .. versionadded:: 8.4 If specified, a callable that will be called with the exception as a parameter after checking the type and the match regex if specified. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. Use ``pytest.raises`` as a context manager, which will capture the exception of the given type, or any of its subclasses:: >>> import pytest >>> with pytest.raises(ZeroDivisionError): ... 1/0 If the code block does not raise the expected exception (:class:`ZeroDivisionError` in the example above), or no exception at all, the check will fail instead. You can also use the keyword argument ``match`` to assert that the exception matches a text or regex:: >>> with pytest.raises(ValueError, match='must be 0 or None'): ... raise ValueError("value must be 0 or None") >>> with pytest.raises(ValueError, match=r'must be \d+$'): ... raise ValueError("value must be 42") The ``match`` argument searches the formatted exception string, which includes any `PEP-678 `__ ``__notes__``: >>> with pytest.raises(ValueError, match=r"had a note added"): # doctest: +SKIP ... e = ValueError("value must be 42") ... e.add_note("had a note added") ... raise e The ``check`` argument, if provided, must return True when passed the raised exception for the match to be successful, otherwise an :exc:`AssertionError` is raised. >>> import errno >>> with pytest.raises(OSError, check=lambda e: e.errno == errno.EACCES): ... raise OSError(errno.EACCES, "no permission to view") The context manager produces an :class:`ExceptionInfo` object which can be used to inspect the details of the captured exception:: >>> with pytest.raises(ValueError) as exc_info: ... raise ValueError("value must be 42") >>> assert exc_info.type is ValueError >>> assert exc_info.value.args[0] == "value must be 42" .. warning:: Given that ``pytest.raises`` matches subclasses, be wary of using it to match :class:`Exception` like this:: # Careful, this will catch ANY exception raised. with pytest.raises(Exception): some_function() Because :class:`Exception` is the base class of almost all exceptions, it is easy for this to hide real bugs, where the user wrote this expecting a specific exception, but some other exception is being raised due to a bug introduced during a refactoring. Avoid using ``pytest.raises`` to catch :class:`Exception` unless certain that you really want to catch **any** exception raised. .. note:: When using ``pytest.raises`` as a context manager, it's worthwhile to note that normal context manager rules apply and that the exception raised *must* be the final line in the scope of the context manager. Lines of code after that, within the scope of the context manager will not be executed. For example:: >>> value = 15 >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... assert exc_info.type is ValueError # This will not execute. Instead, the following approach must be taken (note the difference in scope):: >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... >>> assert exc_info.type is ValueError **Expecting exception groups** When expecting exceptions wrapped in :exc:`BaseExceptionGroup` or :exc:`ExceptionGroup`, you should instead use :class:`pytest.RaisesGroup`. **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise an exception and others do not. See :ref:`parametrizing_conditional_raising` for an example. .. seealso:: :ref:`assertraises` for more examples and detailed discussion. **Legacy form** It is possible to specify a callable by passing a to-be-called lambda:: >>> raises(ZeroDivisionError, lambda: 1/0) or you can specify an arbitrary callable with arguments:: >>> def f(x): return 1/x ... >>> raises(ZeroDivisionError, f, 0) >>> raises(ZeroDivisionError, f, x=0) The form above is fully supported but discouraged for new code because the context manager form is regarded as more readable and less error-prone. .. note:: Similar to caught exception objects in Python, explicitly clearing local references to returned ``ExceptionInfo`` objects can help the Python interpreter speed up its garbage collection. Clearing those references breaks a reference cycle (``ExceptionInfo`` --> caught exception --> frame stack raising the exception --> current frame stack --> local variables --> ``ExceptionInfo``) which makes Python keep all objects referenced from that cycle (including all local variables in the current frame) alive until the next cyclic garbage collection run. More detailed information can be found in the official Python documentation for :ref:`the try statement `. T>r,r+r-z6Unexpected keyword arguments passed to pytest.raises: , z" Use context-manager form instead?NzCExpected an exception type or a tuple of exception types, but got `z`. Raising exceptions is already understood as failing the test, so you don't need any special code to say 'this should never raise an exception'.rz object (type: z) must be callabler5)setjoinsorted TypeError RaisesExc ValueErrorcallabletype)r-rArB__tracebackhide__msgr?excinfos r6r7r7hsR  7 v;;AAA A !JC 499VF^^,, ,C 8 8CC..  %&&v&& &+66v666   ORd O O O   7D D>>R4PP$t**PPPQQQ % & &"' d122h!&!!!""""""""""""""" GG s C))C-0C-5C88C; Pattern[str]str | Pattern[str]c4|jtkr|jn|S)zJHelper function to remove redundant `re.compile` calls when printing regex)flags_REGEX_NO_FLAGSpattern)r+s r6_match_patternr[:s!K?::5==Er8funCallable[[BaseExcT_1], bool]strc t|S)zjGet the repr of a ``check`` parameter. Split out so it can be monkeypatched (e.g. by hypothesis) )repr)r\s r6 repr_callablera?s 99r8scd|zdzS)N`r5rbs r6 backquoterfGs 7S=r8e5type[BaseException] | tuple[type[BaseException], ...]ct|tr|jSt|dkr |djSddd|DzdzS)NrIr(rHc3$K|] }|jV dSr4)__name__).0ees r6 z'_exception_type_name..Rs$3322;333333r8)) isinstancerQrllenrKrgs r6_exception_type_namertKsd!Tz 1vv{{t} 3333333 3c 99r8 expected_type.osXAG!Q^<a!;1QU8t+;r8)any enumerate)rbrs`@r6is_fully_escapedrlsR#NKTUV<< r8c.tjdd|S)Nz\\([{}()+-.*?^$\[\]\s\\])z\1)resubres r6unescaperts 6.q 9 99r8cbeZdZdZddZddZeddZd dZd!dZ e d"dZ dS)#AbstractRaiseszFABC with common functionality shared between RaisesExc and RaisesGroupr+str | Pattern[str] | Noner,$Callable[[BaseExcT_co], bool] | Noner1Nonect|tryd} tj||_n#tj$r }|}Yd}~nd}~wwxYw|t d||dkr#tjtddn||_d|_ t|ts%t|try|j tkrit|tr|j}|rK|ddkr?|dd kr3t|d drt!|d d|_ ||_d|_d |_d |_dS) Nz+Invalid regex pattern provided to 'match': r)zmatching against an empty string will *always* pass. If you want to check for an empty message you need to pass '^$'. If you don't want to match you should pass `None` or leave out the parameter.) stacklevelr^$rIF)rqr^rcompiler+errorrwarningswarnrrawmatchrrXrYrZrrr, _fail_reason_nestedis_baseexception)selfr+r,re_errorrgs r6__init__zAbstractRaises.__init__s eS ! ! H 24*U2C2C 8    #M8MMNNN{{ ![ ! DJ%) eS ! ! 6 ug & & 6+0;/+I+I%)) &  6!HOO"I$$$U1R4[11%!)qt 5 5  (,# !&s3AA  Aexc%type[BaseExcT_1] | types.GenericAliasexpectedr^type[BaseExcT_1]c|t|tr3t|trt|tsd|_|St |}|rt|trt|d}t|tr|ttfvs%t|trL|ttfvrA+++=H<<< c4  8Scl#6677 7 c= ) ) SC"QDII > >   !N N  ur8TypeGuard[BaseExcT_1]cdS)zCheck if an exception matches the requirements of this AbstractRaises. If it fails, :meth:`AbstractRaises.fail_reason` should be set. Nr5rrws r6matcheszAbstractRaises.matchessr8N)r+rr,rr1r)rrrr^r1r)r1ry)rrrwr!r1r)rgrxr1r)rrrwrxr1r) rl __module__ __qualname____doc__rrpropertyrrrrrr5r8r6rr~sPP2&2&2&2&h#8#8#8#8J!!!X!    ####J   ^   r8rceZdZdZedddd(d Zedd d)dZed*dZ d+dddd,fdZd-dZd.dZd/dZd0d Z d1d'Z xZ S)2rNa .. versionadded:: 8.4 This is the class constructed when calling :func:`pytest.raises`, but may be used directly as a helper class with :class:`RaisesGroup` when you want to specify requirements on sub-exceptions. You don't need this if you only want to specify the type, since :class:`RaisesGroup` accepts ``type[BaseException]``. :param type[BaseException] | tuple[type[BaseException]] | None expected_exception: The expected type, or one of several possible types. May be ``None`` in order to only make use of ``match`` and/or ``check`` The type is checked with :func:`isinstance`, and does not need to be an exact match. If that is wanted you can use the ``check`` parameter. :kwparam str | Pattern[str] match A regex to match. :kwparam Callable[[BaseException], bool] check: If specified, a callable that will be called with the exception as a parameter after checking the type and the match regex if specified. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. :meth:`RaisesExc.matches` can also be used standalone to check individual exceptions. Examples:: with RaisesGroup(RaisesExc(ValueError, match="string")) ... with RaisesGroup(RaisesExc(check=lambda x: x.args == (3, "hello"))): ... with RaisesGroup(RaisesExc(check=lambda x: type(x) is ValueError)): ... .r*r-Atype[BaseExcT_co_default] | tuple[type[BaseExcT_co_default], ...]r+rr,,Callable[[BaseExcT_co_default], bool] | Noner1rcdSr4r5)rr-r+r,s r6rzRaisesExc.__init__M sr8r9rr<&Callable[[BaseException], bool] | NonecdSr4r5)rr+r,s r6rzRaisesExc.__init__Y sr8r;cdSr4r5)rr,s r6rzRaisesExc.__init__csNQcr8NHtype[BaseExcT_co_default] | tuple[type[BaseExcT_co_default], ...] | Nonect||t|tr|}n|d}n|f}|dkr||t dtfd|D_d_dS)Nr*r5z4You must specify at least one parameter to match on.c3FK|]}|dVdS)za BaseException type)rN)rrmrgrs r6roz%RaisesExc.__init__..{sH) )  OOA(>O ? ?) ) ) ) ) ) r8F)superrrqtuplerOexpected_exceptions_just_propagate)rr-r+r,r __class__s` r6rzRaisesExc.__init__fs uE222 (% 0 0 8"4    '"$  #5"7  2 % %5=U]STT T#() ) ) ) () ) ) $ $  %r8rwBaseException | NoneTypeGuard[BaseExcT_co_default]cd|_| d|_dS||s d|_dS||sdS||S)aCheck if an exception matches the requirements of this :class:`RaisesExc`. If it fails, :attr:`RaisesExc.fail_reason` will be set. Examples:: assert RaisesExc(ValueError).matches(my_exception): # is equivalent to assert isinstance(my_exception, ValueError) # this can be useful when checking e.g. the ``__cause__`` of an exception. with pytest.raises(ValueError) as excinfo: ... assert RaisesExc(SyntaxError, match="foo").matches(excinfo.value.__cause__) # above line is equivalent to assert isinstance(excinfo.value.__cause__, SyntaxError) assert re.search("foo", str(excinfo.value.__cause__) FNexception is NoneT)rr _check_typerrrs r6rzRaisesExc.matchessq, %   3D 5 ** #'D 5  ++ 5  +++r8r^cXg}|jr'|t|j|j*|dt |j|j*|dt |jdd|dS)Nmatch=check=z RaisesExc(rHrp)rappendrtr+r[r,rarK)r parameterss r6__repr__zRaisesExc.__repr__s  # N   243KLL M M M : !   7 3377    : !   B}TZ'@'@BB C C C4DIIj114444r8rxcHt|j||_|jduSr4)r~rrrs r6rzRaisesExc._check_types%+D,DiPP D((r8"ExceptionInfo[BaseExcT_co_default]c@tj|_|jSr4r for_laterrTrs r6 __enter__zRaisesExc.__enter__s;H;R;T;T |r8rtype[BaseException] | Noneexc_valexc_tbtypes.TracebackType | Nonercd}|b|jstdt|jdkrtd|jtd|jd|j Jd||s|jrdSt |jtd |||f}|j |dS) NTzDID NOT RAISE any exceptionrIzDID NOT RAISE any of zDID NOT RAISE r:Internal error - should have been constructed in __enter__FzJtuple[type[BaseExcT_co_default], BaseExcT_co_default, types.TracebackType]) rrrrrTrrAssertionErrorrr fill_unfilled)rrrrrRexc_infos r6__exit__zRaisesExc.__exit__s !  + 423334+,,q00IT-EIIJJJ A$":1"=AA B B B|'' H(''||G$$ 4# u !233 3 X w '   ""8,,,tr8)r-rr+rr,rr1r)rr<r+rr,rr1r)r,r;r1rr4)r-rr+rr,r)rwrr1rr1r^)rwrxr1r)r1rrrrrrrr1r) rlrrrrrrrrrr __classcell__rs@r6rNrNsB%%Z,/>A     X 9< XQQQXQ  %,0>B%%%%%%%%8!,!,!,!,F 5 5 5 5)))) r8rNc2eZdZdZeddd_d Zed d dd`dZed d ddadZed d ddbdZed d ddcd!Zed d dddd%Zed d dded)Zed d ddfd-Zddd d d.dgfd1Zdhfd7 Zedid9Zedjd;Zdkd=Zdld>ZdmdAZ edndEZ edodGZ dpdHZ e dqdMZ e drdPZ edsdUZedtdVZdudWZdvd]Zdld^ZxZS)w RaisesGroupad .. versionadded:: 8.4 Contextmanager for checking for an expected :exc:`ExceptionGroup`. This works similar to :func:`pytest.raises`, but allows for specifying the structure of an :exc:`ExceptionGroup`. :meth:`ExceptionInfo.group_contains` also tries to handle exception groups, but it is very bad at checking that you *didn't* get unexpected exceptions. The catching behaviour differs from :ref:`except* `, being much stricter about the structure by default. By using ``allow_unwrapped=True`` and ``flatten_subgroups=True`` you can match :ref:`except* ` fully when expecting a single exception. :param args: Any number of exception types, :class:`RaisesGroup` or :class:`RaisesExc` to specify the exceptions contained in this exception. All specified exceptions must be present in the raised group, *and no others*. If you expect a variable number of exceptions you need to use :func:`pytest.raises(ExceptionGroup) ` and manually check the contained exceptions. Consider making use of :meth:`RaisesExc.matches`. It does not care about the order of the exceptions, so ``RaisesGroup(ValueError, TypeError)`` is equivalent to ``RaisesGroup(TypeError, ValueError)``. :kwparam str | re.Pattern[str] | None match: If specified, a string containing a regular expression, or a regular expression object, that is tested against the string representation of the exception group and its :pep:`678` `__notes__` using :func:`re.search`. To match a literal string that may contain :ref:`special characters `, the pattern can first be escaped with :func:`re.escape`. Note that " (5 subgroups)" will be stripped from the ``repr`` before matching. :kwparam Callable[[E], bool] check: If specified, a callable that will be called with the group as a parameter after successfully matching the expected exceptions. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. :kwparam bool allow_unwrapped: If expecting a single exception or :class:`RaisesExc` it will match even if the exception is not inside an exceptiongroup. Using this together with ``match``, ``check`` or expecting multiple exceptions will raise an error. :kwparam bool flatten_subgroups: "flatten" any groups inside the raised exception group, extracting all exceptions inside any nested groups, before matching. Without this it expects you to fully specify the nesting structure by passing :class:`RaisesGroup` as expected parameter. Examples:: with RaisesGroup(ValueError): raise ExceptionGroup("", (ValueError(),)) # match with RaisesGroup( ValueError, ValueError, RaisesExc(TypeError, match="^expected int$"), match="^my group$", ): raise ExceptionGroup( "my group", [ ValueError(), TypeError("expected int"), ValueError(), ], ) # check with RaisesGroup( KeyboardInterrupt, match="^hello$", check=lambda x: isinstance(x.__cause__, ValueError), ): raise BaseExceptionGroup("hello", [KeyboardInterrupt()]) from ValueError # nested groups with RaisesGroup(RaisesGroup(ValueError)): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # flatten_subgroups with RaisesGroup(ValueError, flatten_subgroups=True): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # allow_unwrapped with RaisesGroup(ValueError, allow_unwrapped=True): raise ValueError :meth:`RaisesGroup.matches` can also be used directly to check a standalone exception group. The matching algorithm is greedy, which means cases such as this may fail:: with RaisesGroup(ValueError, RaisesExc(ValueError, match="hello")): raise ExceptionGroup("", (ValueError("hello"), ValueError("goodbye"))) even though it generally does not care about the order of the exceptions in the group. To avoid the above you should specify the first :exc:`ValueError` with a :class:`RaisesExc` as well. .. note:: When raised exceptions don't match the expected ones, you'll get a detailed error message explaining why. This includes ``repr(check)`` if set, which in Python can be overly verbose, showing memory locations etc etc. If installed and imported (in e.g. ``conftest.py``), the ``hypothesis`` library will monkeypatch this output to provide shorter & more readable repr's. F)flatten_subgroupsr-*type[BaseExcT_co] | RaisesExc[BaseExcT_co]allow_unwrapped Literal[True]rrr1rcdSr4r5)rr-rrs r6rzRaisesGroup.__init__Prr8Nr*other_exceptionsr+rr,8Callable[[BaseExceptionGroup[BaseExcT_co]], bool] | NonecdSr4r5)rr-rr+r,rs r6rzRaisesGroup.__init__[s sr8rRaisesGroup[ExcT_1] type[ExcT_1] | RaisesExc[ExcT_1]/Callable[[ExceptionGroup[ExcT_1]], bool] | NonecdSr4r5rr-r+r,rs r6rzRaisesGroup.__init__krr8#RaisesGroup[ExceptionGroup[ExcT_2]]RaisesGroup[ExcT_2]?Callable[[ExceptionGroup[ExceptionGroup[ExcT_2]]], bool] | NonecdSr4r5r s r6rzRaisesGroup.__init__urr8,RaisesGroup[ExcT_1 | ExceptionGroup[ExcT_2]]6type[ExcT_1] | RaisesExc[ExcT_1] | RaisesGroup[ExcT_2]HCallable[[ExceptionGroup[ExcT_1 | ExceptionGroup[ExcT_2]]], bool] | NonecdSr4r5r s r6rzRaisesGroup.__init__rr8RaisesGroup[BaseExcT_1](type[BaseExcT_1] | RaisesExc[BaseExcT_1]7Callable[[BaseExceptionGroup[BaseExcT_1]], bool] | NonecdSr4r5r s r6rzRaisesGroup.__init__rr8+RaisesGroup[BaseExceptionGroup[BaseExcT_2]]RaisesGroup[BaseExcT_2]KCallable[[BaseExceptionGroup[BaseExceptionGroup[BaseExcT_2]]], bool] | NonecdSr4r5r s r6rzRaisesGroup.__init__rr88RaisesGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]Btype[BaseExcT_1] | RaisesExc[BaseExcT_1] | RaisesGroup[BaseExcT_2]XCallable[[BaseExceptionGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]], bool] | NonecdSr4r5r s r6rzRaisesGroup.__init__s $sr8)rrr+r,ARaisesGroup[ExcT_1 | BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]bCallable[[BaseExceptionGroup[BaseExcT_1]], bool] | Callable[[ExceptionGroup[ExcT_1]], bool] | Nonec~td|}t|||_|_d_|r|rt d|r$t|trt d|r||t dtfd|g|RD_ dS)NzVCallable[[BaseExceptionGroup[ExcT_1|BaseExcT_1|BaseExceptionGroup[BaseExcT_2]]], bool]r*FzYou cannot specify multiple exceptions with `allow_unwrapped=True.` If you want to match one of multiple possible exceptions you should use a `RaisesExc`. E.g. `RaisesExc(check=lambda e: isinstance(e, (...)))`z`allow_unwrapped=True` has no effect when expecting a `RaisesGroup`. You might want it in the expected `RaisesGroup`, or `flatten_subgroups=True` if you don't care about the structure.ax`allow_unwrapped=True` bypasses the `match` and `check` parameters if the exception is unwrapped. If you intended to match/check the exception you should use a `RaisesExc` object. If you want to match/check the exceptiongroup when the exception *is* wrapped you need to do e.g. `if isinstance(exc.value, ExceptionGroup): assert RaisesGroup(...).matches(exc.value)` afterwards.c3DK|]}|dVdS)z/a BaseException type, RaisesExc, or RaisesGroupN)_parse_excgrouprs r6roz'RaisesGroup.__init__..sH    $U V V      r8) r rrrrrrOrqrrr)rr-rrr+r,rrs` r6rzRaisesGroup.__init__s1* d    uE222.'8 %  / J   z*Plll 77%%c844 4r8%ExceptionInfo[ExceptionGroup[ExcT_1]]cdSr4r5rs r6rzRaisesGroup.__enter__s 14r8-ExceptionInfo[BaseExceptionGroup[BaseExcT_1]]cdSr4r5rs r6rzRaisesGroup.__enter__s 9<r80ExceptionInfo[BaseExceptionGroup[BaseException]]c@tj|_|jSr4rrs r6rzRaisesGroup.__enter__"s  # % % |r8cd|jD}|jr|d|j|jr|d|j|j*|dt |j|j*|dt|jdd|dS) Ncdg|]-}t|tr|jnt|.Sr5)rqrQrlr`rmrgs r6 z(RaisesGroup.__repr__..)sC   %Q-- :AJJ477   r8zallow_unwrapped=zflatten_subgroups=rrz RaisesGroup(rHrp) rrrrr+r[r,rarK)rreqss r6rzRaisesGroup.__repr__(s  -      C KKA4+?AA B B B  ! G KKET-CEE F F F : ! KK? !;!;?? @ @ @ : ! KK<tz!:!:<< = = =0diioo0000r8 exceptionsSequence[BaseException]cg}|D]Z}t|tr.|||jE||[|S)z!Used if `flatten_subgroups=True`.)rqr'extend_unroll_exceptionsr1r)rr1resrs r6r5zRaisesGroup._unroll_exceptions8sh $&  C#122  4223>BBCCCC 3 r8rwr!TypeGuard[ExceptionGroup[ExcT_1]]cdSr4r5rs r6rzRaisesGroup.matchesFs -0Cr8)TypeGuard[BaseExceptionGroup[BaseExcT_1]]cdSr4r5rs r6rzRaisesGroup.matchesKs 58Cr8c xd|_| d|_dSt|tsdt|jd}t |jdkr ||_dS||jd|}| |jrdS| |d |_n|jr||_n||_dS|j }|j r| |}| |stt|j|_|j}t |t |jcxkrdkrnnt|jdx}trt|dx}|r{| |rf|j Jd |j|cxurnJ|xjd ||d |jd t#|jdz c_n||_dS|||stt|j|_|jJ|j}|j st'd|jDsct'd|DrJ||| |j rd|jvrdnd}|d|dz|_n||_dS||stt|jdt|jz} t |t |jcxkrdkrjnngt|jdx}trE||dr*| d||d|jdz|_n| |_dSdS)a0Check if an exception matches the requirements of this RaisesGroup. If it fails, `RaisesGroup.fail_reason` will be set. Example:: with pytest.raises(TypeError) as excinfo: ... assert RaisesGroup(ValueError).matches(excinfo.value.__cause__) # the above line is equivalent to myexc = excinfo.value.__cause assert isinstance(myexc, BaseExceptionGroup) assert len(myexc.exceptions) == 1 assert isinstance(myexc.exceptions[0], ValueError) NrFrdz()` is not an exception grouprIrTz-, but would match with `allow_unwrapped=True`z$can't be None if _check_match failedz but matched the expected `z*`. You might want `RaisesGroup(RaisesExc(z, match=z))`c3@K|]}t|tVdSr4)rqrr.s r6roz&RaisesGroup.matches..s=34Jq+..r8c3@K|]}t|tVdSr4)rqr'r.s r6roz&RaisesGroup.matches..s-UUa 1&899UUUUUUr8r r)z-Did you mean to use `flatten_subgroups=True`?z on the z', but did return True for the expected z'. You might want RaisesGroup(RaisesExc(z, check=<...>)))rrqr'rQrlrrr_check_expectedrr1rr5rr r^r+_repr_expectedr[_check_exceptionsrr) rrw not_group_msgr6actual_exceptions old_reasonractualrreasons r6rzRaisesGroup.matchesQs$!   3D 5)%788 XY 8WWWM4+,,q00$1!u&&t'?'BINNC{t3{t{$SSS!!% 2$'!!$1!55>5I  ! K $ 7 78I J J   ++  $S$*; < !>!>BP6PPPQ!! %/!5  ++ S$+,,/T$y//:R/T/TT %&&#d.F*G*GLLLL1LLLLL4+CA+FFxMMM%%&7&:;;M %+`d>Q>QRZ>[>[``=E=N```%!! %+!5tr8ruKtype[BaseException] | RaisesExc[BaseException] | RaisesGroup[BaseException]rxryct|trt||S||}|rdS|jJ|jdrd|dt |jdS|d|jS)zHelper method for `RaisesGroup.matches` and `RaisesGroup._check_exceptions` to check one of potentially several expected exceptions.Nrz: r>)rqrQr~rr startswithr)rurwr6s r6r?zRaisesGroup._check_expecteds mT * * ="=)<< <##I..  4(444  $ / / 5 5 UT TT6-2KT+R+RTT T@@]%>@@@r8rg3type[BaseException] | AbstractRaises[BaseException]cht|trt|St|S)zhGet the repr of an expected type/RaisesExc/RaisesGroup, but we only want the name if it's a type)rqrQrtr`rss r6r@zRaisesGroup._repr_expecteds/ a   +'** *Awwr8 _exceptionrrCSequence[Exception]cdSr4r5rrLrCs r6rAzRaisesGroup._check_exceptionss -0Cr8cdSr4r5rOs r6rAzRaisesGroup._check_exceptionss 58Cr8cV tj}ttt }g}i}t jD]p\}}|D]S} || } ||| | | || | ||<nT| |q|s|sdSdt cxkrt jkrnn |rJ| _ dSt jD]\\}}t D]G\} } | || r||| || H]|r*t |dt |dkrdnddnd} |s/| |r| d fd |D_ dS|sE| |r0d fd |D}| d |d_ dSdt |cxkrt |krZnnW| |rB| |r-| ||d|d_ dSd}|r|d| z }d}d}|s|dz }n|s|dz }|r#|dz }d|D}|D]}|d|j|z }t D]u\} } ||| Z|d|dt%t'| dt%j|| zz }v|r|dz }|D]} |d|| dz }t jD]\}}||| } ||vr(| J| ddkr|dz }|t)| |z }| T|d|dt%|dt%t'||z }t jt krt+|r|dz }|_ dS)z]Helper method for RaisesGroup.matches that attempts to pair up expected and actual exceptionsNTrIFz matched exceptionrbr)z. zUnexpected exception(s): c g|] }| Sr5r5)rmrrCs r6r/z1RaisesGroup._check_exceptions..0sDDDa&q)DDDr8rHc3XK|]$}j|V%dSr4)r@r)rmrrs r6roz0RaisesGroup._check_exceptions..5sM))##D$z z Too few exceptions raised!z Unexpected exception(s)!z8 The following expected exceptions did not find a match:ci|]\}}|| Sr5r5)rmkvs r6 z1RaisesGroup._check_exceptions..Ts<<>%'"$ ))ABB . .OE8) . .**85Fu5MNN""5%555;$++E222%*GENE  &&u---   4 %&& G G G G#d.F*G*G G G G G G    #D 5 ))ABB  OE8$-.?$@$@   &%%eX66""8T%9%9(F%K%K  s7|| R Rc'llQ6F6FssB R R R R  7#>#>?O#P#P !IIDDDD3CDDDII  5 G$A$A/$R$R #yy))))()))   $2 v vcs v v vD 5 %&& > > > >#o*>*> > > > > >++,<== ?--o>> ?$2 p73E3EoVWFXZjklZm3n3n p pD 5   ' &n&& &A . / /AA  . - -A  = L LA<bXbb)DLL2I2Ibbb# // $ 8X9N OA   J I IA(  H @h@ 1( ;@@@ @A#,T-E#F#F  x((99O++???1v~~T X...A;fXff)D..s 5 5 5AZ 5 5 5r8r5)rmrrs r6r/z)ResultHolder.__init__..s<C C C :; 5 5!4 5 5 5C C C r8re)rrrCs ` r6rzResultHolder.__init__s8C C C C ?PC C C  r8rintrEresultryc&||j||<dSr4r)rrrErs r6r]zResultHolder.set_results)/ VX&&&r8cB|j||}|tusJ|Sr4rerz)rrrEr6s r6rbzResultHolder.get_results)l6"8,*$$$$ r8rc6|j||tuSr4r)rrrEs r6r_zResultHolder.has_results|F#H-Z??r8 list[int]c^|D])}|jD]}||tusJ||dS *dSNFTr)rrractual_resultss r6raz"ResultHolder.no_match_for_expecteds] ! !A"&, ! !%a( ::::!!$, 555- !tr8cR|D]#}|j|D]}|tusJ|dS$dSrr)rrErr6s r6r`z ResultHolder.no_match_for_actualsV ! !A|A ! !*,,,,; 555 !tr8N)rr|rCr2r1r)rrrErrryr1r)rrrErr1ry)rrrErr1r)rrr1r)rErr1r) rlrrrrr]rbr_rar`r5r8r6rZrZs     0000 @@@@r8rZreusedset[int] | Nonectt}|tjkrdStfdt j|DS)NTc3VK|]#\}}|duo|vot|hzV$dSr4)rd)rmrvalrers r6roz!possible_match..s] Q t M M.$!**M*Mr8)rJrrrerr)rercurr_rows`` r6rdrds |uu4yyH3w''''t !'/(";<<  r8)r-r.r+r/r,r0r1r2)r+r:r,r;r1r<)r,r;r1r<) r-r.r?r@rArrBrr1rCr4)r-rErArrBrr1rF)r+rUr1rV)r\r]r1r^)rbr^r1r^)rgrhr1r^)rurvrwrxr1ry)rbr^r1r)rerZrrr1r)D __future__rabcrrrrsystextwraprtypingrr r r r r rrrr _pytest._coder_pytest._code.coder_pytest.outcomesr_pytest.warning_typesrcollections.abcrrtypestyping_extensionsrrrrrxrrr r!r"rr#r$ version_infoexceptiongroupr'r(rrXrYr7r[rarfrtr~rrrrNrrzrZrdr5r8r6rs""""""   ''''''222222!!!!!!//////((((((((((((LLL++++++++++++)))))) #A"'  =-@@@AA!']d gm=DIII W\ 7 7 7 W\ 7 7 7  + + +  + + +g111111------"*S//' +.!$   .1 ##### # VVV V  @DDDDDD^>FFFF ::::.::::] ] ] ] ] S'+.] ] ] @{{{{{23{{{|S CS CS CS CS C.!3K!@AS CS CS Cl99999999********Z       r8