fZ fddlmZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZer*ddlZddlZddlmZmZmZddlmZmZedeed Zndd lmZeded Zed ed Zejdkrddlm Z eGddeeZ!ere!Z"n ddl#m"Z"n #e$$re!Z"YnwxYwddZ%ej&dj'Z(eGddeeZ)ere Z*neZ*eGddee"e ee*eZ+dS)) annotationsN) TYPE_CHECKINGCallableContextManagerGenericLiteralPatternSequencecastoverload)warn_deprecated)final)ExceptionChainReprReprExceptionInfo Traceback) TypeGuardTypeVarMatchET)bounddefault covariant)r)rrE) )BaseExceptionGroupceZdZUdZded<d(dZd)d Zed*d Ze d+dZ e d,dZ e d-dZ d.d/dZ d0dZ d1d2d&Zd'S)3_ExceptionInfozMinimal re-implementation of pytest.ExceptionInfo, only used if pytest is not available. Supports a subset of its features necessary for functionality of :class:`trio.testing.RaisesGroup` and :class:`trio.testing.Matcher`.7tuple[type[MatchE], MatchE, types.TracebackType] | None_excinfoexcinfoc||_dSNr)selfr s ]/var/www/api.educacionweb.es/myenv/lib/python3.11/site-packages/trio/testing/_raises_group.py__init__z_ExceptionInfo.__init__3s  exc_info0tuple[type[MatchE], MatchE, types.TracebackType]returnNonec6|j Jd||_dS)z|j Jd|jdS)zThe exception class.Nz6.type can only be used after the context manager exitsrr#r$s r%typez_ExceptionInfo.typeEs* M % % C & % %}Qr'rc>|j Jd|jdS)zThe exception value.Nz7.value can only be used after the context manager exitsr#r5s r%valuez_ExceptionInfo.valueMs* M % % D & % %}Qr'types.TracebackTypec>|j Jd|jdS)zThe exception raw traceback.Nz4.tb can only be used after the context manager exitsr#r5s r%tbz_ExceptionInfo.tbUs* M % % A & % %}Qr'Ftryshortboolstrc tdNz_This is a helper method only available if you use RaisesGroup with the pytest package installedNotImplementedError)r$r>s r%exconlyz_ExceptionInfo.exconly]s! m   r'excGbuiltins.type[BaseException] | tuple[builtins.type[BaseException], ...]c tdrBrC)r$rFs r% errisinstancez_ExceptionInfo.errisinstancebs" m   r'longT showlocalsstyleabspathtbfilter,bool | Callable[[_ExceptionInfo], Traceback]funcargstruncate_localschain&ReprExceptionInfo | ExceptionChainReprc tdrBrC)r$rKrLrMrNrPrQrRs r%getreprz_ExceptionInfo.getreprjs" m   r'N)r r)r(r)r*r+)r*r.)r*r3)r*r)r*r:)F)r>r?r*r@)rFrGr*r?)FrJFTFTT)rKr?rLr@rMr?rNrOrPr?rQr?rRr?r*rS)__name__ __module__ __qualname____doc____annotations__r&r- classmethodr2propertyr6r9r=rErIrUr0r'r%rr-s3iiEEEE    !!!![    X    X    X          !AE $        r'r) ExceptionInforF BaseExceptionr*r@c dt|dt|gt|dgS)N message __notes__)joingetattrr@)rFs r%_stringify_exceptionresF 99 CCHH - - S+r * *   r'ceZdZdZe ddd Zedd ddZed dZ d!d"dZd#dZd$dZdS)%MatcheraHelper class to be used together with RaisesGroups when you want to specify requirements on sub-exceptions. Only specifying the type is redundant, and it's also unnecessary when the type is a nested `RaisesGroup` since it supports the same arguments. The type is checked with `isinstance`, and does not need to be an exact match. If that is wanted you can use the ``check`` parameter. :meth:`trio.testing.Matcher.matches` can also be used standalone to check individual exceptions. Examples:: with RaisesGroups(Matcher(ValueError, match="string")) ... with RaisesGroups(Matcher(check=lambda x: x.args == (3, "hello"))): ... with RaisesGroups(Matcher(check=lambda x: type(x) is ValueError)): ... .r$Matcher[MatchE]exception_typer3matchstr | Pattern[str]checkCallable[[MatchE], bool]cdSr"r0r$rjrkrms r%r&zMatcher.__init__s  sr')rmMatcher[BaseException]Callable[[BaseException], bool]cdSr"r0)r$rkrms r%r&zMatcher.__init__s  sr'cdSr"r0)r$rms r%r&zMatcher.__init__sCF3r'Ntype[MatchE] | Nonestr | Pattern[str] | NoneCallable[[MatchE], bool] | Nonec|||td|(t|tstd|d||_|t |t rt j||_n||_||_ dS)Nz4You must specify at least one parameter to match on.zexception_type z$ must be a subclass of BaseException) ValueError issubclassr^rj isinstancer@recompilerkrmrps r%r&zMatcher.__init__s  !em STT T  %j.W.W %V.VVV - ' eS ! ! E**DJJDJ r' exceptionr^r*TypeGuard[MatchE]c|jt||jsdS|j)tj|jt |sdS|jdup'|tt|S)aCheck if an exception matches the requirements of this Matcher. Examples:: assert Matcher(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 Matcher(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__) NF) rjr{rkr|searchrermr r)r$r~s r%matcheszMatcher.matchess$   *: t*4 4 *5 : !") J,Y77+ + !5zT!HTZZVY0G0G%H%HHr'r@c<g}|j||jj|jx}/|d|jt kr|jn||j|d|jdd|dS)Nzmatch=zcheck=zMatcher(, )) rjappendrVrkflags_regex_no_flagspatternrmrc)r$reqsrks r%__str__zMatcher.__str__s   * KK+4 5 5 5Z E , KKW%+*H*HeWW    : ! KK/// 0 0 0,$))D//,,,,r')..)r$rirjr3rkrlrmrn)r$rqrkrlrmrr)rmrr)NNN)rjrurkrvrmrw)r~r^r*rr*r@)rVrWrXrYr r&rrr0r'r%rhrhs   %(*-     X  25      X FFFXF/3+/15 (IIII< - - - - - -r'rhceZdZdZerd1dZedd d d d2dZedd d dd3dZeddd d dd4dZddd d d dd5d Zd6d"Zd7d%Z d8d)Z d9d.Z d:d0Z d S); RaisesGroupa Contextmanager for checking for an expected `ExceptionGroup`. This works similar to ``pytest.raises``, and a version of it will hopefully be added upstream, after which this can be deprecated and removed. See https://github.com/pytest-dev/pytest/issues/11538 The catching behaviour differs from :ref:`except* ` in multiple different ways, being much stricter by default. By using ``allow_unwrapped=True`` and ``flatten_subgroups=True`` you can match ``except*`` fully when expecting a single exception. #. All specified exceptions must be present, *and no others*. * If you expect a variable number of exceptions you need to use ``pytest.raises(ExceptionGroup)`` and manually check the contained exceptions. Consider making use of :func:`Matcher.matches`. #. It will only catch exceptions wrapped in an exceptiongroup by default. * With ``allow_unwrapped=True`` you can specify a single expected exception or `Matcher` and it will match the exception even if it is not inside an `ExceptionGroup`. If you expect one of several different exception types you need to use a `Matcher` object. #. By default it cares about the full structure with nested `ExceptionGroup`'s. You can specify nested `ExceptionGroup`'s by passing `RaisesGroup` objects as expected exceptions. * With ``flatten_subgroups=True`` it will "flatten" the raised `ExceptionGroup`, extracting all exceptions inside any nested :class:`ExceptionGroup`, before matching. It currently does not care about the order of the exceptions, so ``RaisesGroups(ValueError, TypeError)`` is equivalent to ``RaisesGroups(TypeError, ValueError)``. This class is not as polished as ``pytest.raises``, and is currently not as helpful in e.g. printing diffs when strings don't match, suggesting you use ``re.escape``, etc. Examples:: with RaisesGroups(ValueError): raise ExceptionGroup("", (ValueError(),)) with RaisesGroups(ValueError, ValueError, Matcher(TypeError, match="expected int")): ... with RaisesGroups(KeyboardInterrupt, match="hello", check=lambda x: type(x) is BaseExceptionGroup): ... with RaisesGroups(RaisesGroups(ValueError)): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # flatten_subgroups with RaisesGroups(ValueError, flatten_subgroups=True): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # allow_unwrapped with RaisesGroups(ValueError, allow_unwrapped=True): raise ValueError `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 RaisesGroups(ValueError, Matcher(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 ValueError with a Matcher as well. It is also not typechecked perfectly, and that's likely not possible with the current approach. Most common usage should work without issue though. argsobjectkwargsr*RaisesGroup[E]cdSr"r0)r1rrs r%__new__zRaisesGroup.__new__Nsr'FN)flatten_subgroupsrkrmr~type[E] | Matcher[E]allow_unwrapped Literal[True]rr?rkr+rmcdSr"r0)r$r~rrrkrms r%r&zRaisesGroup.__init__R  sr')rrkrmother_exceptionsLiteral[False]rv.Callable[[BaseExceptionGroup[E]], bool] | NonecdSr"r0r$r~rrrkrmrs r%r&zRaisesGroup.__init__^rr')rrrkrmtype[E] | Matcher[E] | EcdSr"r0rs r%r&zRaisesGroup.__init__irr')rrrkrmstrictrc|g|R|_||_||_||_||_d|_|t dddd| |_|r|rtd|r$t|trtd|r||td |jD]}t|tr,|jrtd |xj|jzc_Ct|tr2|j `|xjt|j t zc_t|tr:t|tr%|xjt|t zc_td |d dS) NFzThe `strict` parameterz0.25.1i z)flatten_subgroups=True (for strict=False})issueinsteadzYou cannot specify multiple exceptions with `allow_unwrapped=True.` If you want to match one of multiple possible exceptions you should use a `Matcher`. E.g. `Matcher(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.av`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 `Matcher` 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.zYou cannot specify a nested structure inside a RaisesGroup with `flatten_subgroups=True`. The parameter will flatten subgroups in the raised exceptiongroup before matching, which would never match a nested structure.zInvalid argument "z2" must be exception type, Matcher, or RaisesGroup.)expected_exceptionsrr match_exprrmis_baseexceptiongroupr ryr{rrhrjrz Exceptionr6r^) r$r~rrrkrmrrrFs r%r&zRaisesGroup.__init__ts4 J J J  (9. %*"   (C      *0ZD "  / H   z)[AA S    1U5FK +  C#{++ )$5 **c.GG***C)) %-***& 33/***C&& :c=+I+I ***S)2L2L.LL*** $$$$-  r'$ExceptionInfo[BaseExceptionGroup[E]]c@tj|_|jSr")r]r2r r5s r% __enter__zRaisesGroup.__enter__s=J=T=V=V |r' exceptionsSequence[BaseException]cg}|D]Z}t|tr.|||jE||[|S)z!Used if `flatten_subgroups=True`.)r{rextend_unroll_exceptionsrr)r$rresrFs r%rzRaisesGroup._unroll_exceptionssh$&  C#122  4223>BBCCCC 3 r'exc_valBaseException | None TypeGuard[BaseExceptionGroup[E]]c|dSt|tsi|jr`|jd}t|tr||rdSt|t rt||rdSdS|j)tj |jt|sdS|j | |sdSt|j}|j }|jr||}t!|t!|jkrdS|D]}|D]}t|t rt||sTt|t"r||s*t|tr,||r||ndSdS)aCheck if an exception matches the requirements of this RaisesGroup. Example:: with pytest.raises(TypeError) as excinfo: ... assert RaisesGroups(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) NFrT)r{rrrrhrr6rr|rrermlistrrrlenrremove)r$rexp_excremaining_exceptionsactual_exceptionserem_es r%rzRaisesGroup.matchess" ?5'#566 # 215gw// GOOG4L4L 4gt,, GW1M1M 45 ? &ry O1'::0 0 &5 : !$**W*=*= !5#D$<==5<5G  ! K $ 7 78I J J   ! !S)A%B%B B B5 #  A-  t,,1;Au1E1E"5+66;@==;K;K#5'228=}}Q7G7G )//666Euutr'exc_typetype[BaseException] | Noneexc_tbtypes.TracebackType | Nonecd}|Jd||j Jd||sdStd|||f}|j|dS)NTz&DID NOT RAISE any exception, expected z:Internal error - should have been constructed in __enter__FzNtuple[type[BaseExceptionGroup[E]], BaseExceptionGroup[E], types.TracebackType]) expected_typer rr r-)r$rrr__tracebackhide__r(s r%__exit__zRaisesGroup.__exit__s !  JD4F4F4H4H J J !  L $ $ G % $ $||G$$ 5 \ w '   ""8,,,tr'r@cg}|jD]}t|tr#|t |:t|t r(||wt|tr||jtd|j rdnd}|dd |dS)Nz unknown typeBaserfzExceptionGroup(rr) rr{rhrr@rrr6rVAssertionErrorrrc)r$subexcsr group_types r%rzRaisesGroup.expected_type-s) 5 5A!W%% 5s1vv&&&&A{++ 5q001111At$$ 5qz****$^444#9AVVr BBTYYw-?-?BBBBr')rrrrr*r) r~rrrrr?rkr+rmr+) r~rrrrrrrrkrvrmr) r~rrrrrrrrkrvrmr)r~rrrrr?rr?rkrvrmrrr+)r*r)rrr*r)rrr*r)rrrrrrr*r?r) rVrWrXrYrrr r&rrrrrr0r'r%rrsy66rQPPPP #(     X  +0+/@D     X  +0,1+/@D     X !&"'+/@DNNNNNN`    ====~2 C C C C C Cr'r)rFr^r*r@), __future__rr|systypingrrrrrr r r r trio._deprecater trio._utilrbuiltinstypes_pytest._code.coderrrtyping_extensionsrrr^rr version_infoexceptiongrouprrr]pytest ImportErrorrer}rrrh SuperClassrr0r'r%rs""""""                       ,+++++DOOOLLLSSSSSSSSSS44444444 W }FF WX]d C C CF GC}555g111111H H H H H WV_H H H `'"MM'((((((( '''& ' "*R..&b-b-b-b-b-gfob-b-b-f#JJJgCgCgCgCgC./A!/D!EF ST gCgCgCgCgCs2B99CC