KjޭdZddlmZddlZddlZddlmZddlmZddlmZddlm Z ddl m Z dd l m Z dd l m Z dd l mZddlZdd lmZddlZddlZdd lmZddlmZddlmZddlmZddlmZddlmZddlZddlmZerddlmZne Zd5dZ! d6dZ" d7dZ#edZ$eddZ%GddejLee%Z'dZ(Gdd e'eZ)Gd!d"e'eeefZ*Gd#d$e'eeZ+Gd%d&e'e%Z,Gd'd(e,e Z-Gd)d*e'e e zZ. d8 d9d+Z/d:d,Z0 d;d-Z1dd0Z4d?d1Z5d@d2Z6d@d3Z7d@d4Z8y)Az&The implementation of pytest.approx().) annotationsN) Collection)Mapping)Sequence)Sized)datetime) timedelta)Decimal)FloatOperation)Complex)Any)Generic) SupportsAbs) TYPE_CHECKING) TypeGuard)TypeVar)#PytestApproxDecimalToleranceWarning)ndarrayc"||St||S)aTrack a running maximum without seeding it with a value of another type. Seeding with ``-math.inf`` compares a float against whatever is being accumulated. For Decimal that comparison is exact, but it signals ``decimal.FloatOperation`` when that trap is set, and the sequence variant used to swallow the signal (``decimal.FloatOperation`` is a ``TypeError`` subclass) and report ``-inf`` as the difference. )max)current candidates S/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/_pytest/approx.py _max_diffr%s 9DS)-DDc||rtj}|tj n||tj fS|fS)zTurn the accumulators into the values shown in the failure message. ``-math.inf`` means "no difference could be computed at all", which happens when every mismatched element is a non-number (#13012). )mathinf) max_abs_diff max_rel_diffrel_diff_is_infinites r _vetted_diffsr"1sExx !) |!)  /; rct|}|jddgd}|D]W\}} } t|dt||d<t|dt| |d<t|dt| |d<Ydt|d|dd |d |g|D cgc](\} } } | d |dd d | d |dd d | d |dd *c} } } z} | Scc} } } w)Nr)IndexObtainedExpected)rrrz(comparison failed. Mismatched elements: z / :zMax absolute difference: zMax relative difference: <z | )listinsertrlen) full_object message_datanumber_of_elements different_idsrr message_list max_sizesindexobtainedexpectedindexes explanations r_compare_approxr:As2 %L<=I%18!x9Q<U4 ! 9Q<X7 ! 9Q<X7 ! 8 33}3E2FcJ\I]]^_ #L>2 #L>2 ,8   'GXx 1Yq\N " #3x)A,p/?&@HQyYZ|n\\L\C]^  K   s-C T ExpectedTT) covariantceZdZdZdZdZdZ d dZejd dZ ddZ ddZ d Z dZ dd Zdd Zy)ApproxzThe return type of :func:`pytest.approx`. ``Approx`` objects support (approximate) equality comparisons and ``repr``, and can also be used with ``isinstance(..., pytest.Approx)``. .. versionadded:: 9.2 pytestNdc<||_||_||_||_yN)r7relabsnan_ok)selfr7rDrErFs r__init__zApprox.__init__ns !  rctrCNotImplementedErrorrGs r__repr__zApprox.__repr__~s!!rcdd|d|gS)Ncomparison failed Obtained: Expected: )rG other_sides r _repr_comparezApprox._repr_compares#  %   rcJtfdj|DS)Nc3LK|]\}}|j|k(ywrC_approx_scalar).0axrGs r z Approx.__eq__..s* ,0AqA$$Q' ' s!$)all_yield_comparisonsrGactuals` r__eq__z Approx.__eq__s( 484K4KF4S   rcd}td)NTzVapprox() is not supported in a boolean context. Did you mean: `assert a == approx(b)`?)AssertionError)rG__tracebackhide__s r__bool__zApprox.__bool__s  e  rc\t|tr-t||j|j|j St|t tfr-t||j|j|j St||j|j|j S)NrDrErF) isinstancer ApproxDecimalrDrErFrr ApproxTimedelta ApproxScalar)rGr[s rrXzApprox._approx_scalarsr a ! dhht{{S S a(I. /"1$((U UA488$++NNrct)zoYield all the pairs of numbers to be compared. This is used to implement the `__eq__` method. rJr_s rr^zApprox._yield_comparisonss "!r r7r<rD"float | Decimal | timedelta | NonerErnrFboolreturnNonerpstr)rp list[str]rpro)rpz#ApproxScalar[Any] | ApproxTimedeltar`object)__name__ __module__ __qualname____doc____array_ufunc____array_priority__rHabcabstractmethodrMrTrare__hash__rXr^rRrrr?r?_sJO00       ""   HO"rr?ct|ttzrt|}|fd|DSt |r|Dcgc]}t |c}S|Scc}w)z=Recursively map a function over a sequence of arbitrary depthc36K|]}t|ywrC)_recursive_sequence_map)rYxifs rr\z*_recursive_sequence_map..sC2/26Cs)rhr,tupletype_is_sequence_liker)rr[seq_typers` rrrsZ!TE\"7CCCC 1 9:;2'2.;;t .get_value_from_nested_lists&%E !a !Lrz3Impossible to compare arrays with different shapes.zShapes:  and Fc32K|]}t|ywrC)range)rYrs rr\z,ApproxNumpy._repr_compare..s(Jaq(JsT)rz list[Any]rztuple[Any, ...]rpr ) itertoolsr7shaperrXr_as_numpy_arraysizeproductrErappendr"rsr:)rGrSrrnp_array_shapeapprox_side_as_seqother_side_as_arrayr1rr r!r2r5 approx_value other_valueabs_diffr0s rrTzApproxNumpy._repr_compares " .=   ,,4   !5!5!7  .j9"... 066 6E>*%0C0I0I/JK  "]]//  $ &Y&&(J>(JK ,E56H%PL45H%PK{*|44{BC(x@ !#+/(#,\8c+FV;V#WL$$U+ ,&3 ,(<& " l'   E ./BEJK./A5IJ    MM         s?5Fcddl}|j|s |j|}|j|s$|j |j j k7ryt|!|S#t$r}t d|d|d}~wwxYw)Nrzcannot compare 'z' to numpy.ndarrayF) numpyisscalarasarray Exception TypeErrorrr7superra)rGr`npe __class__s rrazApproxNumpy.__eq__s{{6" VF+{{6"v||t}}7J7J'Jw~f%%  V"26(:L MNTUU VsA-- B 6BB c#hKddl}|j|rG|j|jjD]}|t |j|f y|j|jjD]*}t ||t |j|f,yw)Nr)rrndindexr7r_unbox_numpy_scalar)rGr`rrs rr^zApproxNumpy._yield_comparisonss ;;v ZZ 3 34 D1$--2BCCC DZZ 3 34 'q 2' a(89 sB0B2rr)rSzndarray | list[Any]rprtru) rxryrzr{rMrTrar^ __classcell__rs@rrrsR+ B H& rrcZeZdZdZ dfd ZddZd dZd fd ZdZxZ S) ApproxMappingzyPerform approximate comparisons where the expected value is a mapping with numeric values (the keys can be anything).c d}|jD]A\}}t|sd}t|j||t j |t |||||y)NTz[pytest.approx() does not support nested dictionaries: key={!r} value={!r} full mapping={}rg)items_is_nested_containerrformatpprintpformatrrH) rGr7rDrErFrdkeyrmsgrs rrHzApproxMapping.__init__$sm!"..* RJC#E*t 3v~~h7O PQQ R sFCrc d|jjDcic]\}}||j|c}}dScc}}wr)r7rrX)rGkvs rrMzApproxMapping.__repr__4sB$--BUBUBWX$!QAt22155X\\]^^XsAc t|jt|k7r&ddt|jdt|gS|jj|jk7r0dd|jjd|jgS|jjDcic]\}}||j |}}}t|}d}d}d}g} |jD]\} } || } | | k7s| jf| d t |t | j| z }| jdk(rd }n/t |t | j| z | jz }| j| t|||\}}| D cgc](} t| t|| t|| f*}} t|j||| ||Scc}}w#t$rYwxYwcc} w) Nz4Impossible to compare mappings with different sizes. Lengths: rzcomparison failed.z&Mappings has different keys: expected z but got FrT) r.r7keysrrXrrEZeroDivisionErrorrr"rsr:)rGrSrrapprox_side_as_mapr1rr r!r2 approx_keyrrrr0s rrTzApproxMapping._repr_compare7sN t}} Z 0FC ./uS_4EF  ==   :??#4 4$89K9K9M8NiXbXgXgXiWjk  37--2E2E2G *.!QAt""1% %  !!34  $ (:(@(@(B 1 $J $Z0K{*((49P'0( 5 5 CD( (00A5370+4 , #%1%:%:[%H&2&;&;%<!",L$$Z0/ 12&3 ,(<& " l % Xs:c?+S1CC1H-I J   MM        W <- sG5"A#G;,-H ; HHc t|jt|jjk7ry t||S#t$rYywxYwNF)setrr7AttributeErrorrrarGr`rs rrazApproxMapping.__eq__ysZ 6;;=!S););)=%>>? w~f%%  s=A AAc#ZK|jD]}|||j|fywrCr7)rGr`rs rr^z ApproxMapping._yield_comparisonss1 .A)T]]1-- - .s)+) r7zMapping[Any, Any]rDrnrErnrFrorprqrr)rSzMapping[object, float]rprtru rxryrzr{rHrMrTrar^rrs@rrr sZ7D#D0D0 D  D  D _@ D&.rrcZeZdZdZ dfd ZddZd dZd fd ZdZxZ S) ApproxSequenceLikezRPerform approximate comparisons where the expected value is a sequence of numbers.c d}t|D]A\}}t|sd}t|j||t j |t |||||y)NTz]pytest.approx() does not support nested data structures: {!r} at index {} full sequence: {}rg) enumeraterrrrrrrH) rGr7rDrErFrdr5r[rrs rrHzApproxSequenceLike.__init__sk!!(+ PHE1#A&v 1eV^^H5M NOO P sFCrctj}|ttfvrt}d|fdjDdS)Nrc3@K|]}j|ywrCrW)rYr[rGs rr\z.ApproxSequenceLike.__repr__..s!PQ$"5"5a"8!Pr)rr7rr,)rGrs` rrMzApproxSequenceLike.__repr__sB & E4= (H!P$--!PPSSTUUrc t|jt|k7r&ddt|jdt|gSt|j|j}t|}d}d}d}g}t t ||dD]e\}\} } | | k7s t | j| z } t|| }| dk(rd}nt|| t | z } |j|gt|||\}}|Dcgc](}t|t||t||f*} }t|j| ||||S#t$rt$rYwxYwcc}w)Nz1Impossible to compare lists with different sizes.rrFTstrictr)r.r7rrXrziprErr rrr"rsr:) rGrSrr1rr r!r2rrrrr0s rrTz ApproxSequenceLike._repr_compares t}} Z 0CC ./uS_4EF  5T5H5H$--X !34  $ .7 "Jt </  ( *A* k{*"<#8#8;#FGH#,\8#DL#a'/3,'0((S5E*E( $$Q'+ (.&3 ,(<& " l # VSA'-?-B)C D   MM        -&  s"$E-E/E,+E,c t|t|jk7ry t||S#t$rYywxYwr)r.r7rrrars rrazApproxSequenceLike.__eq__sJ 6{c$--001w~f%%  s!5 AAc2t||jdS)NTr)rr7r_s rr^z%ApproxSequenceLike._yield_comparisonss64==66r) r7z Sequence[Any]rDrnrErnrFrorprqrr)rSzSequence[float]rprtrurrs@rrrsW\DD0D0 D  D  D V 5 n&7rrceZdZUdZdZded<dZded<ded<ded < dfd Zdd Zdd Z d Z e dZ xZ S)rkzLPerform approximate comparisons where the expected value is a single number.g-q=zfloat | DecimalDEFAULT_ABSOLUTE_TOLERANCEgư>DEFAULT_RELATIVE_TOLERANCEzfloat | Decimal | NonerDrEcd}|mt|tttfs!t dt |j t|ts!t dt |j |2235 ?:cC3H#ICy))*,  sFCrcjt|js?t|jttzrt t |jrt|jS t|jtr|jd}n5d|jcxkrdkrnn|jd}n|jd}t|jtr0|jjrt |js|dz }|jd|S#t$rd}YwxYw)uReturn a string communicating both the expected value and the tolerance for the comparison being made. For example, ``1.0 ± 1e-6``, ``(3+4j) ± 5e-6 ∠ ±180°``. z.1egMbP?g@@nu ∠ ±180°z??? ± ) _is_boolr7rhr r _is_infrErs toleranceimag ValueError)rGvetted_tolerances rrMzApproxScalar.__repr__s T]] #t}}g.?@s4==)*t}}% % %$..'2 '+nnS%9 -#-&*nnQ%7 &*nnS%9 4=='2MM&&/ N2 --%5$677 %$  %s+B(D$$ D21D2cdt|}|tfd|jDStjr t|sy|jk(rytjs8t jt tzrt |t tzsyttjr"jxrtt|Sttjrytj|z jk}|S)ziReturn whether the given value is equal to the expected value within the pre-specified tolerance.c3@K|]}j|ywrC)ra)rYrZrGs rr\z&ApproxScalar.__eq__..8s?H  %tDHH: 6#H: .$(( $   =) H s"AA,+A,) r7zdatetime | timedeltarDrnrErnrFrorprqrrrurv)rSr rprt) rxryrzr{rHrMrar^rTrrs@rrjrjsX9I&9I09I0 9I  9I  9Iv0 $  rrjcd}t|||t|trt||||St|trt ||||St |x}t||||St|rt||||St|tr't|ttzsd|}t|t|ttfrt!||||St#||||S)a$Assert that two numbers (or two ordered sequences of numbers) are equal to each other within some tolerance. Due to the :doc:`python:tutorial/floatingpoint`, numbers that we would intuitively expect to be equal are not always so:: >>> 0.1 + 0.2 == 0.3 False This problem is commonly encountered when writing tests, e.g. when making sure that floating-point values are what you expect them to be. One way to deal with this problem is to assert that two floating-point numbers are equal to within some appropriate tolerance:: >>> abs((0.1 + 0.2) - 0.3) < 1e-6 True However, comparisons like this are tedious to write and difficult to understand. Furthermore, absolute comparisons like the one above are usually discouraged because there's no tolerance that works well for all situations. ``1e-6`` is good for numbers around ``1``, but too small for very big numbers and too big for very small ones. It's better to express the tolerance as a fraction of the expected value, but relative comparisons like that are even more difficult to write correctly and concisely. The ``approx`` class performs floating-point comparisons using a syntax that's as intuitive as possible:: >>> from pytest import approx >>> 0.1 + 0.2 == approx(0.3) True The same syntax also works for ordered sequences of numbers:: >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6)) True ``numpy`` arrays:: >>> import numpy as np # doctest: +SKIP >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == approx(np.array([0.3, 0.6])) # doctest: +SKIP True And for a ``numpy`` array against a scalar:: >>> import numpy as np # doctest: +SKIP >>> np.array([0.1, 0.2]) + np.array([0.2, 0.1]) == approx(0.3) # doctest: +SKIP True Only ordered sequences are supported, because ``approx`` needs to infer the relative position of the sequences without ambiguity. This means ``sets`` and other unordered sequences are not supported. Finally, dictionary *values* can also be compared:: >>> {'a': 0.1 + 0.2, 'b': 0.2 + 0.4} == approx({'a': 0.3, 'b': 0.6}) True The comparison will be true if both mappings have the same keys and their respective values match the expected tolerances. **Tolerances** By default, ``approx`` considers numbers within a relative tolerance of ``1e-6`` (i.e. one part in a million) of its expected value to be equal. This treatment would lead to surprising results if the expected value was ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``. To handle this case less surprisingly, ``approx`` also considers numbers within an absolute tolerance of ``1e-12`` of its expected value to be equal. Infinity and NaN are special cases. Infinity is only considered equal to itself, regardless of the relative tolerance. NaN is not considered equal to anything by default, but you can make it be equal to itself by setting the ``nan_ok`` argument to True. (This is meant to facilitate comparing arrays that use NaN to mean "no data".) Both the relative and absolute tolerances can be changed by passing arguments to the ``approx`` constructor:: >>> 1.0001 == approx(1) False >>> 1.0001 == approx(1, rel=1e-3) True >>> 1.0001 == approx(1, abs=1e-3) True If you specify ``abs`` but not ``rel``, the comparison will not consider the relative tolerance at all. In other words, two numbers that are within the default relative tolerance of ``1e-6`` will still be considered unequal if they exceed the specified absolute tolerance. If you specify both ``abs`` and ``rel``, the numbers will be considered equal if either tolerance is met:: >>> 1 + 1e-8 == approx(1) True >>> 1 + 1e-8 == approx(1, abs=1e-12) False >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12) True **Non-numeric types** You can also use ``approx`` to compare non-numeric types, or dicts and sequences containing non-numeric types, in which case it falls back to strict equality. This can be useful for comparing dicts and sequences that can contain optional values:: >>> {"required": 1.0000005, "optional": None} == approx({"required": 1, "optional": None}) True >>> [None, 1.0000005] == approx([None,1]) True >>> ["foo", 1.0000005] == approx([None,1]) False **datetime and timedelta** You can also use ``approx`` to compare :class:`~datetime.datetime` and :class:`~datetime.timedelta` objects by specifying an absolute tolerance as a :class:`~datetime.timedelta`:: >>> from datetime import datetime, timedelta >>> dt1 = datetime(2024, 1, 1, 12, 0, 0) >>> dt2 = datetime(2024, 1, 1, 12, 0, 0, 500000) >>> dt1 == approx(dt2, abs=timedelta(seconds=1)) True Note that ``rel`` is not supported for datetime comparisons. For timedelta comparisons, ``rel`` is a number (not a timedelta) that represents a relative tolerance -- a fraction of the expected value. ``abs`` must be a ``timedelta`` object in both cases. .. versionadded:: 8.4 If you're thinking about using ``approx``, then you might want to know how it compares to other good ways of comparing floating-point numbers. All of these algorithms are based on relative and absolute tolerances and should agree for the most part, but they do have meaningful differences: - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``: True if the relative tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute tolerance is met. Because the relative tolerance is calculated w.r.t. both ``a`` and ``b``, this test is symmetric (i.e. neither ``a`` nor ``b`` is a "reference value"). You have to specify an absolute tolerance if you want to compare to ``0.0`` because there is no tolerance by default. More information: :py:func:`math.isclose`. - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference between ``a`` and ``b`` is less that the sum of the relative tolerance w.r.t. ``b`` and the absolute tolerance. Because the relative tolerance is only calculated w.r.t. ``b``, this test is asymmetric and you can think of ``b`` as the reference value. Support for comparing sequences is provided by :py:func:`numpy.allclose`. More information: :std:doc:`numpy:reference/generated/numpy.isclose`. - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b`` are within an absolute tolerance of ``1e-7``. No relative tolerance is considered , so this function is not appropriate for very large or very small numbers. Also, it's only available in subclasses of ``unittest.TestCase`` and it's ugly because it doesn't follow PEP8. More information: :py:meth:`unittest.TestCase.assertAlmostEqual`. - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative tolerance is met w.r.t. ``b`` or if the absolute tolerance is met. Because the relative tolerance is only calculated w.r.t. ``b``, this test is asymmetric and you can think of ``b`` as the reference value. In the special case that you explicitly specify an absolute tolerance but not a relative tolerance, only the absolute tolerance is considered. .. note:: ``approx`` can handle numpy arrays, but we recommend the specialised test helpers in :std:doc:`numpy:reference/routines.testing` if you need support for comparisons, NaNs, or ULP-based tolerances. To match strings using regex, you can use `Matches `_ from the `re_assert package `_. .. note:: Unlike built-in equality, this function considers booleans unequal to numeric zero or one. For example:: >>> 1 == approx(True) False .. warning:: .. versionchanged:: 3.2 In order to avoid inconsistent behavior, :py:exc:`TypeError` is raised for ``>``, ``>=``, ``<`` and ``<=`` comparisons. The example below illustrates the problem:: assert approx(0.1) > 0.1 + 1e-10 # calls approx(0.1).__gt__(0.1 + 1e-10) assert 0.1 + 1e-10 > approx(0.1) # calls approx(0.1).__lt__(0.1 + 1e-10) In the second example one expects ``approx(0.1).__le__(0.1 + 1e-10)`` to be called. But instead, ``approx(0.1).__lt__(0.1 + 1e-10)`` is used to comparison. This is because the call hierarchy of rich comparisons follows a fixed behavior. More information: :py:meth:`object.__ge__` .. versionchanged:: 3.7.1 ``approx`` raises ``TypeError`` when it encounters a dict value or sequence element of non-numeric type. .. versionchanged:: 6.1.0 ``approx`` falls back to strict equality for non-numeric types instead of raising ``TypeError``. Trgz:pytest.approx() only supports ordered sequences, but got: )"_warn_on_inexact_decimal_tolerancerhr rirrrrrrrrsbytesrrr rjrk)r7rDrErFrdnp_arrayrs rapproxrsP&xc:(G$X3CGG Hg &X3CGG%h/ /( <8#fEE 8 $!(VLL Hj )*XsU{2SJ8,Wn Hx3 4xSc&IIH#3vFFrct|tryt|tr td|j DSt |rt |d|}td|DSy)zFWhether a comparison against ``expected`` will use Decimal arithmetic.Tc3<K|]}t|tywrCrhr rYrs rr\z$_contains_decimal..sM%:eW-Mrc3<K|]}t|tywrCrrs rr\z$_contains_decimal.. sB%:eW-BrF)rhr ranyvaluesrgetattr)r7rs r_contains_decimalrs](G$(G$M8??;LMMM"684B6BBB rcd|fd|ffDcgc]D\}}t|tur.tj|tt |k7r||fF}}}|r t |sy|D]P\}}t jt|d|dtj|d|dt|d d Rycc}}w) a+Warn when a float tolerance is used for a Decimal comparison. A float tolerance is converted with ``Decimal.from_float()``, which is exact and therefore keeps the float's full binary expansion: ``rel=0.01`` really means a tolerance of ``0.010000000000000000208...``. That is wider than the ``0.01`` that was written, which defeats the point of comparing Decimals in the first place. Only floats that cannot be represented exactly are worth warning about; ``0.5`` and friends survive the conversion unchanged, as do ints. rDrEN=z? cannot be represented exactly as a Decimal and was widened to z. Pass z =Decimal(z-) to compare against the tolerance you wrote.) stacklevel) rrr rreprrwarningswarnrrs)r7rDrEnamerinexacts rrrs$#CL5#,7 D% ;% G$6$6u$=eAU$U u G +H5  e /&%#&&-&8&8&?%@AvYs5zn5'(     sA B<crt|dxr*t|txrt|ttz S)N __getitem__)hasattrrhrrsrrs rrr4s6-( 2 x ' 28S5[1 1rcdt|txrt|ttztz S)zWhether ``value`` is a container ``approx`` cannot descend into. ``str``, ``bytes`` and ``bytearray`` are collections as well, but they compare exactly and are handled as leaves, so they are not nesting. )rhrrsr bytearray)rs rrr<s2 eZ (  sU{Y&2.rctjjd}|S|j|ryt ||j r|St |ds t |dr|j|Sy)z Return an ndarray if the given object is implicitly convertible to ndarray, and numpy is already imported, otherwise None. rN __array____array_interface__)sysmodulesgetrrhrr'r)objrs rrrGsb kkoog&B ~ ;;s  RZZ (J S+ &'#7L*M::c? " rc2t|dd}||S|S)zReturn the Python object behind a numpy scalar. Indexing an object-dtype array yields the stored Python object, which has no ``item()`` of its own -- only numpy's own scalar types need unboxing. itemN)r)rr2s rrrXs# 5&$ 'DL5,df,rct|trytjj dx}rt||j Sy)NTrF)rhror-r.r/bool_)valrs rrrbs;#t [[__W %%r%#rxx(( rclt|tr|jStj|SrC)rhr is_nanrrr5s rrrks(#wzz| ::c?rclt|tr|jStj|SrC)rhr is_infiniterrr8s rrrss'#w  ::c?r)rr rr rpr )rr r r r!rorpztuple[Any, Any])r/rwr0zSequence[tuple[str, str, str]]r1rr2zSequence[object]rrr rrprt)NNF) r7r;rDrnrErnrFrorpz Approx[T])r7rwrpro)r7rwrDrnrErnrprq)r7rwrpzTypeGuard[Sequence[Any]])rrwrpro)r0rwrpzndarray | None)rr rpr )r5r rpro)9r{ __future__rr~rcollections.abcrrrrrr decimalr r rnumbersr rr-typingr rrrrrr!_pytest.warning_typesrrrrwrr"r:r;r<ABCr?rrrrrkrirjrrrrrrrrrrrRrrrBs',# &#$!"   EG E  %( @D   0$     4 CL K4 0 D"SWWgi(D"Nl&/l^d.F738,-d.NY7 .Y7xi;6)$i;X7L)74Z fX 12Z ~/3.2 zGzG +zG ,zG  zG  zGz     +   ,    F"-r