#)fE ddlmZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZerddlZddlZddlmZmZmZddlmZej0dkrddlmZe d e ZeGd d eeZereZn dd lmZddZ!ejDdjFZ$eGddeeZ%ereZ&neZ&eGddeeeee&eZ'y#e $reZYawxYw)) annotationsN) TYPE_CHECKINGCallableContextManagerGenericIterablePatternTypeVarcastoverload)final)ExceptionChainReprReprExceptionInfo Traceback) TypeGuard) )BaseExceptionGroupE)boundceZdZUdZded<ddZddZeddZe ddZ e ddZ e dd Z ddd Z dd Z d dd Zy )_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`.-tuple[type[E], E, types.TracebackType] | None_excinfoc||_yNr)selfexcinfos W/var/www/html/flask-app/venv/lib/python3.12/site-packages/trio/testing/_raises_group.py__init__z_ExceptionInfo.__init__)s  c8|jJd||_y)zs. MM % E D E}}Qr"cF|jJd|jdS)zThe exception raw traceback.z4.tb can only be used after the context manager exitsrr+s r tbz_ExceptionInfo.tbFs. MM % B A B}}Qr"ctdNz_This is a helper method only available if you use RaisesGroup with the pytest package installedNotImplementedError)rtryshorts r exconlyz_ExceptionInfo.exconlyNs! m  r"ctdr4r5)rexcs r errisinstancez_ExceptionInfo.errisinstanceSs" m  r"ctdr4r5)r showlocalsstyleabspathtbfilterfuncargstruncate_localschains r getreprz_ExceptionInfo.getrepr[s" m  r"N)rr)r$z&tuple[type[E], E, types.TracebackType]returnNone)rEz_ExceptionInfo[E])rEtype[E])rEr)rEztypes.TracebackType)F)r7boolrEstr)r:zGbuiltins.type[BaseException] | tuple[builtins.type[BaseException], ...]rErH)FlongFTFTT)r=rHr>rIr?rHr@z;bool | Callable[[_ExceptionInfo[BaseException]], Traceback]rArHrBrHrCrHrEz&ReprExceptionInfo | ExceptionChainRepr)__name__ __module__ __qualname____doc____annotations__r!r% classmethodr)propertyr,r/r2r8r;rDr'r"r rr#si;; !         T   !PT $        N         0  r"r) ExceptionInfocRdjt|gt|dgS)N __notes__)joinrIgetattr)r:s r _stringify_exceptionrXzs0 99 H S+r *  r"ceZdZdZe d d dZedd d dZeddZ d ddZdd Zdd Zy)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)): ... .cyrr'rexception_typematchchecks r r!zMatcher.__init__s  r")r`cyrr')rr_r`s r r!zMatcher.__init__s r"cyrr')rr`s r r!zMatcher.__init__sCFr"Nc|| | td|t|tstd|d||_|t |t r"t j||_||_ y||_||_ y)Nz4You must specify at least one parameter to match on.zexception_type z$ must be a subclass of BaseException) ValueError issubclass BaseExceptionr^ isinstancerIrecompiler_r`r]s r r!zMatcher.__init__s  !em ST T  %j.W!.!11UV - eS !E*DJ DJ r"c|jt||jsy|j*tj|jt |sy|j |j tt|syy)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__) FT) r^rgr_rhsearchrXr`r r)r exceptions r matcheszMatcher.matchesst$    *: t**4  :: !")) JJ,Y7+  :: !$**T!Y5G*Hr"chg}|j%|j|jj|jx}3|jd|jt k(r |j n||j|jd|jddj|dS)Nzmatch=zcheck=zMatcher(, )) r^appendrKr_flags_regex_no_flagspatternr`rV)rreqsr_s r __str__zMatcher.__str__s    * KK++44 5ZZ E , KK%++*HeVW  :: ! KK&/ 0$))D/*!,,r")..)rz Matcher[E]r^rGr_str | Pattern[str]r`zCallable[[E], bool])rzMatcher[BaseException]r_rwr`Callable[[BaseException], bool])r`rx)NNN)r^ztype[E] | Noner_str | Pattern[str] | Noner`zCallable[[E], bool] | None)rlrfrEz TypeGuard[E]rErI)rKrLrMrNr r!rmrvr'r"r r[r[s  %(%(    " #    25  $ " /   FF*.+/,0 &)* (@ -r"r[ceZdZdZerd dZdddd d dZddZ ddZ dd Z dd Z dd Z y) 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 This differs from :ref:`except* ` in that all specified exceptions must be present, *and no others*. It will similarly not catch exceptions *not* wrapped in an exceptiongroup. If you don't care for the nesting level of the exceptions you can pass ``strict=False``. 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(),)),)) with RaisesGroups(ValueError, strict=False): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) `RaisesGroup.matches` can also be used directly to check a standalone exception group. This class is also not perfectly smart, e.g. this will likely fail currently:: 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. cyrr')r(argskwargss r __new__zRaisesGroup.__new__0sr"TN)strictr_r`c,|g||_||_||_||_d|_|jD]}t |t r-|s td|xj|jzc_@t |tr<|j]|xjt|jt zc_t |tr5t|tr%|xjt|t zc_td|dy)NFzLYou cannot specify a nested structure inside a RaisesGroup with strict=FalsezInvalid argument "z2" must be exception type, Matcher, or RaisesGroup.)expected_exceptionsr match_exprr`is_baseexceptiongrouprgr|rdr[r^re Exceptionr,rf)rrlrr_r`other_exceptionsr:s r r!zRaisesGroup.__init__2s J J    %*"++ C#{+$(**c.G.GG*C)%%-***&& 3/*C&:c=+I***S)2L.LL* (0$$% r"cLtj|_|jSr)rRr)rr+s r __enter__zRaisesGroup.__enter__Zs=J=T=T=V ||r"cg}|D]N}t|tr+|j|j|j>|j |P|S)zUsed in non-strict mode.)rgrextend_unroll_exceptions exceptionsrq)rrresr:s r rzRaisesGroup._unroll_exceptions^sR$& C#12 4223>>BC 3   r"c|yt|tsyt|jt|jk7ry|j *t j|j t|sy|j|j|syt|j}|j}|js|j|}|D]}|D]}t|tr t||sTt|tr!t|tr|j|s#t|t sa|j|ss|j#|yy)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) FT)rgrlenrrrrhrkrXr`listrrr,r|rmr[remove)rexc_valremaining_exceptionsactual_exceptionserem_es r rmzRaisesGroup.matchesks8" ?'#56 w!! "c$*B*B&C C ?? &ryy OO1':0  :: !$**W*=#D$<$<=5<5G5G{{ $ 7 78I J  # A- t,Au1E"1&89&uk:!MM!,"5'2u}}Q7G(//6  r"cd}|Jd|j|jJd|j|sytd|||f}|jj |y)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_typerrmr r%)rexc_typerexc_tb__tracebackhide__r$s r __exit__zRaisesGroup.__exit__s !   K 3D4F4F4H3I J K LL $ H G H||G$ \ w '  ""8,r"cg}|jD]}t|tr|jt |.t|t r |j|j ^t|tr|j|jtd|jrdnd}|ddj|dS)Nz unknown typeBaserYzExceptionGroup(rorp) rrgr[rqrIr|rr,rKAssertionErrorrrV)rsubexcsr group_types r rzRaisesGroup.expected_types)) 5A!W%s1v&A{+q01At$qzz*$^44 5 $99Vr _TYYw-?,@BBr")r~objectrrrEzRaisesGroup[E]) rltype[E] | Matcher[E] | ErrrrHr_ryr`z.Callable[[BaseExceptionGroup[E]], bool] | None)rEz$ExceptionInfo[BaseExceptionGroup[E]])rIterable[BaseException]rEr)rBaseException | NonerEz TypeGuard[BaseExceptionGroup[E]])rztype[BaseException] | Nonerrrztypes.TracebackType | NonerErHrz) rKrLrMrNrrr!rrrmrrr'r"r r|r|s%PP +/@D &+&4& & ) & > &P 1   7%7 *7r,&+   2 Cr"r|)r:rfrErI)( __future__rrhsystypingrrrrrr r r r trio._utilr builtinstypes_pytest._code.coderrrtyping_extensionsr version_infoexceptiongrouprrfrrrRpytest ImportErrorrXrirrrsr[ SuperClassr|r'r"r rs'"    SS+g1 C}%C WQZC C V"M'( "**R.&&d-gajd-d-j#JJDC./A!/D!EF ST DCDCa '& 's=CC%$C%