_1hgddlmZddlZddlZddlmZmZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZe r/ddlZddlZddlmZmZdd lmZmZmZdd lmZmZed eed Znddl mZed ed Zeded Z edeZ!edeZ"ede#Z$ede#Z%ejLdkrddl'm(Z(m)Z)eGdde eZ*e re*Z+n ddl,m+Z+d,dZ.ej^dj`Z1d-dZ2d.dZ3d/dZ4 d0d Z5Gd!d"ee e Z6eGd#d$e6eZ7eGd%d&e6e(e Z8eGd'd(Z9Gd)d*Z:d1d2d+Z;y#e-$re*Z+YwxYw)3) annotationsN)ABCabstractmethod)Pattern)indent) TYPE_CHECKINGGenericLiteralcastoverload)final)CallableSequence)ExceptionChainReprReprExceptionInfo Traceback) TypeGuardTypeVarMatchET)bounddefault covariant)r)rr BaseExcT_co BaseExcT_1)r BaseExcT_2ExcT_1ExcT_2) )BaseExceptionGroupExceptionGroupceZdZUdZded< ddZ ddZeddZe 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`.7tuple[type[MatchE], MatchE, types.TracebackType] | None_excinfoc||_yNr%)selfexcinfos X/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/trio/testing/_raises_group.py__init__z_ExceptionInfo.__init__:s   c8|jJd||_y)z ('8 DUCVW W!""23D2EFF r-cpeZdZdZ ddZed dZ d dZd dZe d dZ y) AbstractMatcherzDABC with common functionality shared between Matcher and RaisesGroupct|trtj||_n||_||_d|_d|_y)NF)rurTrecompilerjcheck _fail_reason_nestedr)rjrs r+r,zAbstractMatcher.__init__s= eS !.0jj.?DJDJ (,# r-c|jS)zSet after a call to `matches` to give a human-readable reason for why the match failed. When used as a context manager the string will be given as the text of an `AssertionError`)rr6s r+ fail_reasonzAbstractMatcher.fail_reasons    r-c|jy|j|ry|jrdndt|jz}d|d|_y)NTre rz did not return TrueF)rrror)r)rx check_reprs r+ _check_checkzAbstractMatcher._check_checksP ::  ::i < >   !O O r-cy)zCheck if an exception matches the requirements of this AbstractMatcher. If it fails, `AbstractMatcher.fail_reason` should be set. Nr2r)exc_vals r+matcheszAbstractMatcher.matchessr-N)rjstr | Pattern[str] | Nonerz$Callable[[BaseExcT_co], bool] | NonerPrQ)rP str | None)r)AbstractMatcher[BaseExcT_1]rxrrPrS)rr BaseExceptionrPrS)r)rrrrPzTypeGuard[BaseExcT_1]) rVrWrXrYr,r\rrrrrr2r-r+r}r}sN #( #4 #  #!! )    & ) 4A   r-r}ceZdZdZe d d dZedd d dZeddZ d dfd Z ddZdd Zdd ZxZ S)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:`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)): ... Tip: if you install ``hypothesis`` and import it in ``conftest.py`` you will get readable ``repr``s of ``check`` callables in the output. .cyr'r2)r)exception_typerjrs r+r,zMatcher.__init__s r-)rcyr'r2rs r+r,zMatcher.__init__%r-cyr'r2)r)rs r+r,zMatcher.__init__.sKNr-ct||||| | td|t|tstd|d||_y)Nz4You must specify at least one parameter to match on.zexception_type z$ must be a subclass of BaseException)superr, ValueErrorrvrr)r)rrjr __class__s r+r,zMatcher.__init__1sb &  !em ST T  %j.W!.!11UV -r-cl|j|sy|j|sy|j|S)aCheck if an exception matches the requirements of this Matcher. If it fails, `Matcher.fail_reason` will be set. 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__)) F) _check_typerrr)rxs r+rzMatcher.matches@s7, *  +  ++r-c^g}|j%|j|jj|j'|jdt |j|j '|jdt |j ddj|dS)Nmatch=check=zMatcher(, ))rappendrVrjrkrrorb)r) parameterss r+__repr__zMatcher.__repr__^s    *   d11:: ; :: !    367  :: !   }TZZ'@&AB C$))J/022r-cTt|j||_|jduSr')r{rrrs r+rzMatcher._check_typeks(+D,?,?K  D((r-)..)rrRrjstr | Pattern[str]rzCallable[[MatchE], bool]rPrQ)r)zMatcher[BaseException]rjrrCallable[[BaseException], bool]rPrQ)rrrPrQ)NNN)rztype[MatchE] | NonerjrrzCallable[[MatchE], bool] | None)rxrrPzTypeGuard[MatchE]rPrT) rVrWrXrYr r,rrr __classcell__rs@r+rr s$%(*- $"(    25 $" /   NN/3+/15 -+ -) -/ -, , ,< 3)r-rceZdZdZedd ddZeddd d dZeddd d!dZeddd d"d Zeddd d#d Zeddd d$d Zeddd d%d Zeddd d&d Zddddd d'fdZe d(dZe d)dZd*dZd+dZ d,dZe d-dZ e d.dZ d/dZ e d0dZ e d1dZ e d2dZ e d3dZ d4dZ d5dZd+dZxZS)6 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 does not care about the order of the exceptions, so ``RaisesGroups(ValueError, TypeError)`` is equivalent to ``RaisesGroups(TypeError, ValueError)``. 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. Tip: if you install ``hypothesis`` and import it in ``conftest.py`` you will get readable ``repr``s of ``check`` callables in the output. F)flatten_subgroupscyr'r2)r)rxallow_unwrappedrs r+r,zRaisesGroup.__init__rr-N)rjrcyr'r2)r)rxrrjrother_exceptionss r+r,zRaisesGroup.__init__sr-cyr'r2r)rxrjrrs r+r,zRaisesGroup.__init__rr-cyr'r2rs r+r,zRaisesGroup.__init__rr-cyr'r2rs r+r,zRaisesGroup.__init__r-cyr'r2rs r+r,zRaisesGroup.__init__rr-cyr'r2rs r+r,zRaisesGroup.__init__rr-cyr'r2rs r+r,zRaisesGroup.__init__sr-)rrrjrctd|}t| |||g||_||_||_d|_|r |r td|rt|tr td|r|| td|jD]}t|tr>|j r td|xj |j zc_d|_ Qt|trB|j.|xj t|jt zc_d|_ t|tr5t|t r%|xj t|t zc_td|d y) NzVCallable[[BaseExceptionGroup[ExcT_1|BaseExcT_1|BaseExceptionGroup[BaseExcT_2]]], bool]FzYou 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.TzInvalid argument "z2" must be exception type, Matcher, or RaisesGroup.)r rr,expected_exceptionsrris_baseexceptiongrouprrurrrrrv Exceptionr7r) r)rxrrrjrrrErs r+r,zRaisesGroup.__init__s$     &     /'8+0" /H  z)[AS   1U5FK ++ C#{+))$5 **c.G.GG*" C)%%1..j**!73.# C&:c=+I***S)2L.LL* (0$$- r-cyr'r2r6s r+ __enter__zRaisesGroup.__enter__]s14r-cyr'r2r6s r+rzRaisesGroup.__enter__as9|j |P|S)z!Used if `flatten_subgroups=True`.)rur extend_unroll_exceptions exceptionsr)r)rresrEs r+rzRaisesGroup._unroll_exceptions|sR $& C#12 4223>>BC 3   r-cyr'r2rs r+rzRaisesGroup.matchess-0r-cyr'r2rs r+rzRaisesGroup.matchess58r-c Td|_|d|_yt|tst|jd}t |j dkDr||_y|j|j d|}| |jry| |d|_y|jr||_y||_y|j}|jr|j|}|j|s|j}t |t |j cxk(rdk(rnnt|j dx}trt|dx}|r|j|ru|jJd |j|cxurJJ|xjd |j|d |jd t|jd z c_y||_y|j!||s|jJ|j}|jszt#d|j Ds^t#d|DrL|j!||j|jr!d|jvrdnd}|d|dz|_y||_y|j%|S)a1Check 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 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) Nzexception is NoneFz is not an exception groupr9rTz-, 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(Matcher(z, match=z))c3<K|]}t|tywr')rur.0rrs r+ z&RaisesGroup.matches..s34Jq+.c3<K|]}t|tywr')rur rs r+rz&RaisesGroup.matches..sUa 1&89Urr_ rez-Did you mean to use `flatten_subgroups=True`?)rrur r7rVlenr_check_expectedrrrrrrj_repr_expectedrk_check_exceptionsanyr) r)r not_group_msgractual_exceptions old_reasonexpectedactualrs r+rzRaisesGroup.matchess$! ? 3D '#56 $G}5588RSM4++,q0$1!&&t'?'?'BGLC{t33{$o%RS! %%$'!%2!5<5G5G  ! ! $ 7 78I J   )**J%&#d.F.F*GL1L4+C+CA+FFxM):1)==vxH%%f-zz-U/UU-((JBBBBB!!'B4CVCVW_C`BabGHPHYHYGZZbcqrvr|r|c}b@@B&CC!%/!%%   $$0 00**J**8<8P8PUCTUU**++G,>,>?"&T->->!>B6("OPQ! %/!  ))r-ct|tr t||S|j|}|ry|jJ|jj drd|dt |jdS|d|jS)zHelper method for `RaisesGroup.matches` and `RaisesGroup._check_exceptions` to check one of potentially several expected exceptions.Nr_z: r)rur7r{rr startswithr)rwrxrs r+rzRaisesGroup._check_expecteds mT *"=)< <##I. ((444  $ $ / / 5 (6-2K2KT+R*ST T""]%>%>$?@@r-cNt|tr t|St|S)zfGet the repr of an expected type/Matcher/RaisesGroup, but we only want the name if it's a type)rur7rsrmrqs r+rzRaisesGroup._repr_expected s" a '* *Awr-cyr'r2r)_exc_valrs r+rzRaisesGroup._check_exceptionss -0r-cyr'r2rs r+rzRaisesGroup._check_exceptionss 58r-c tj|}ttt |}g}i}t jD]_\}}|D]D} j ||| } |j|| | | .|j| | ||<N|j|a|s|sydt |cxk(rt jk(rnn |rJ _ yt jD]N\}}t |D];\} } |j|| r|j|| j || =P|r!t |dt |dkDrdnddnd} |s/|j|r| d|Dcgc]}|| c}_ y|s7|j|r&| d d jfd |Dd _ ydt |cxk(rt |k(rGnnD|j|r3|j|r"| |j|d |d _ yd}|r|d| z }d}d}|s|dz }n|s|dz }|r(|dz }|j!Dcic]\}}|| }}}|D]{}|d|j#j|z }t |D]E\} } |j| |d|d| dj#j| z }G}|r|dz }|D]} |d||| dz }t jD]a\}}|j|| } ||vr | J| d dk7r|dz }|t%| |z }| ?|d|dj#|d|||z }ct jt |k(rt'|r|dz }|_ ycc}wcc}}w)z]helper method for RaisesGroup.matches that attempts to pair up expected and actual exceptionsTr9Fz matched exceptionsrez. zUnexpected exception(s): z0Too few exceptions raised, found no match for: [rc3ZK|]"}jj|$ywr')rr)rir)s r+rz0RaisesGroup._check_exceptions..\sWmxcdmqnAnABFBZBZ[\B]n^mxs(+]rr_rz z Too few exceptions raised!z Unexpected exception(s)!z8 The following expected exceptions did not find a match:z It matches z which was paired with z5 The following raised exceptions did not find a match:z There exist a possible match when attempting an exhaustive check, but RaisesGroup uses a greedy algorithm. Please make your expected exceptions more stringent with `Matcher` etc so the greedy algorithm can function.) ResultHolderrlistranger enumerater set_resultremoverr has_resultno_match_for_actualno_match_for_expectedrb get_resultitemsrrpossible_match)r)rrresultsremaining_actualfailed_expectedri_expri_remri_actualrsuccessful_strrrindent_1indent_2kv rev_matchesi_faileds` r+rzRaisesGroup._check_exceptions s:t779JK c*;&< =>%'"$ ))A)AB .OE8) .**85Fu5MN""5%5;$++E2%*GEN  . &&u- .  %& G#d.F.F*G G ; #D  ))A)AB OE8$-.?$@  &%%eX6""8T%9%9(F%K  7|n.c'lQ6FsB.Or R 7#>#>?O#P#1"22Kk{L|fgM^_`MaL|K!AD G$A$A/$R#1"22bcgclclmxhwmxdxcyyz!{D  %& >#o*> >++,<=--o>#1"273E3EoVWFXZjklZm3n2o pD    2n%& &A / /A - -A  L LA,3MMO2hZ{6*a@ @A#,T-E-E#F Ox((9O+?*?1v~T X..A;2hZ{43F3Fx3P2QQhiz|CDI|JjKiNOOA O O t'' (C0A,B B~ H  m mA{M}>=s  O= O cFd}|Jd|j|jJd|jrt|tsdnd}|j |sJd|d|j td|||f}|jj|y) NTz&DID NOT RAISE any exception, expected z:Internal error - should have been constructed in __enter__z(group)groupzRaised exception z did not match: zbtuple[type[BaseExceptionGroup[BaseExcT_co]], BaseExceptionGroup[BaseExcT_co], types.TracebackType]) rwr*rrvr rrr r0)r)exc_typerexc_tb__tracebackhide__ group_strr/s r+__exit__zRaisesGroup.__exit__s !   K 3D4F4F4H3I J K  LL $ H G H $ ##JxAS,T   ||   N yk)9$:K:K9L M N  p w '  ""8,r-cg}|jD]}t|tr|jt |.t|t r |j|j ^t|tr|j|jtd|jrdnd}|ddj|dS)Nz unknown typeBaserezExceptionGroup(rr) rrurrrTrrwr7rVAssertionErrorrrb)r)subexcsrr group_types r+rwzRaisesGroup.expected_types)) 5A!W%s1v&A{+q01At$qzz*$^44 5 $99Vr _TYYw-?,@BBr-)rx(type[BaseExcT_co] | Matcher[BaseExcT_co]r Literal[True]rrSrPrQ) rxrrrrrrjrrz8Callable[[BaseExceptionGroup[BaseExcT_co]], bool] | NonerPrQ) r)RaisesGroup[ExcT_1]rxtype[ExcT_1] | Matcher[ExcT_1]rrrjrrz/Callable[[ExceptionGroup[ExcT_1]], bool] | NonerPrQ) r)z#RaisesGroup[ExceptionGroup[ExcT_2]]rxRaisesGroup[ExcT_2]rrrjrrz?Callable[[ExceptionGroup[ExceptionGroup[ExcT_2]]], bool] | NonerPrQ) r)z,RaisesGroup[ExcT_1 | ExceptionGroup[ExcT_2]]rx4type[ExcT_1] | Matcher[ExcT_1] | RaisesGroup[ExcT_2]rrrjrrzHCallable[[ExceptionGroup[ExcT_1 | ExceptionGroup[ExcT_2]]], bool] | NonerPrQ) r)RaisesGroup[BaseExcT_1]rx&type[BaseExcT_1] | Matcher[BaseExcT_1]rrrjrrz7Callable[[BaseExceptionGroup[BaseExcT_1]], bool] | NonerPrQ) r)z+RaisesGroup[BaseExceptionGroup[BaseExcT_2]]rxRaisesGroup[BaseExcT_2]rrrjrrzKCallable[[BaseExceptionGroup[BaseExceptionGroup[BaseExcT_2]]], bool] | NonerPrQ) r)z8RaisesGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]rx@type[BaseExcT_1] | Matcher[BaseExcT_1] | RaisesGroup[BaseExcT_2]rr rjrrzXCallable[[BaseExceptionGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]], bool] | NonerPrQ)r)zARaisesGroup[ExcT_1 | BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]rxr rr rrSrrSrjrrzbCallable[[BaseExceptionGroup[BaseExcT_1]], bool] | Callable[[ExceptionGroup[ExcT_1]], bool] | None)r)rrPz%ExceptionInfo[ExceptionGroup[ExcT_1]])r)rrPz-ExceptionInfo[BaseExceptionGroup[BaseExcT_1]])rPz0ExceptionInfo[BaseExceptionGroup[BaseException]]r)rSequence[BaseException]rPr!)r)rrBaseException | NonerP!TypeGuard[ExceptionGroup[ExcT_1]])r)rrr"rP)TypeGuard[BaseExceptionGroup[BaseExcT_1]])rr"rP*TypeGuard[BaseExceptionGroup[BaseExcT_co]])rwzItype[BaseException] | Matcher[BaseException] | RaisesGroup[BaseException]rxrrPr)rrz4type[BaseException] | AbstractMatcher[BaseException]rPrT)r)rrrrzSequence[Exception]rPr#)r)rrrrr!rPr$)rrrr!rPr%)r type[BaseException] | Nonerr"rztypes.TracebackType | NonerPrS)rVrWrXrYr r,rrrr staticmethodrrrrrwrrs@r+rrps5r #( ;'      ,0JN ;D)  )  H   ,0AE !1:)  ?    ,0QU 1&/)  O    ,0 :GP)  U   ,0IM %9B)  G    ,0 9*3)  X  ,0 FS" )   ,!&"'+/ TOTST"T  T T)T Tl4!4 .44<%< 6<< 7 +  ! 0!0%0 +008%8%8 388 a*%a* 4a*FA UA! A  AA$0!00/0 + 00 8%8838 3 88 uu3u 4 un,&+   @ Cr-rc eZdZy) NotCheckedN)rVrWrXr2r-r+r)r)sr-r)cHeZdZ ddZd dZd dZd dZd dZd dZy)rcf|Dcgc]}|Dcgc]}t c}c}|_ycc}wcc}wr')r)r)r)rr_s r+r,zResultHolder.__init__s4@QC :;!4 5AZ 5C  5C s . ) ..c(||j||<yr')r)r)rrresults r+rzResultHolder.set_results)/ VX&r-cN|j||}t|trJ|Sr')rrur7)r)rrrs r+rzResultHolder.get_results*ll6"8,c4((( r-c2|j||tuSr'rr))r)rrs r+rzResultHolder.has_results||F#H-Z??r-c^|D](}|jD]}||tusJ||y*yNFTr1)r)rractual_resultss r+rz"ResultHolder.no_match_for_expectedsJ !A"&,, !%a( :::!!$,  ! ! r-cX|D]%}|j|D]}|tusJ|y'yr3r1)r)rrrs r+rz ResultHolder.no_match_for_actualsC !A||A !*,,,;  ! ! r-N)rz@tuple[type[BaseException] | AbstractMatcher[BaseException], ...]rr!rPrQ)rintrr6r.rrPrQ)rr6rr6rPr)rr6rr6rPrS)r list[int]rPrS)rr7rPrS) rVrWrXr,rrrrrr2r-r+rrs?     3    0 @r-rc| t}t|}|t|jk(ryt|j|D]\}}| ||vst |||hzsyy)NTF)setrrrr)rusedcurr_rowrvals r+rrsn |u4yH3w''GOOH563 ;1D=^GTQCZ-P r-)rErrPrT)rjz Pattern[str]rPr)rnzCallable[[BaseExcT_1], bool]rPrT)rrztype[BaseException]rPrT)rwr&rxrrPrr')rrr:zset[int] | NonerPrS)< __future__rrsysabcrrrtextwraprtypingrr r r r trio._utilr builtinstypescollections.abcrr_pytest._code.coderrrtyping_extensionsrrrrrrrrrr version_infoexceptiongroupr r!r#r]pytest ImportErrorrdrrgrhrkrorsr{r}rrr)rrr2r-r+rLs" #2SS4 F X]d CFm=DI \ 7 \ 7  +  +gAJ WV_J J d"M'( "**S/''F -*A c7;/A Hc)of%c)c)LR C/"4["ABR CR Cj&&R M '& 'sE//E98E9