F-PhjxpddlmZddlmZddlmZddlmZddlmZddlmZddl Z ddl m Z ddl Z ddl Z dd lmZdd lmZerdd lmZd1dZGddZdZGddeZGdd eZGd!d"eZGd#d$eZGd%d&eZd2d3d*Zd4d,Zd5d.Zd6d0ZdS)7) annotations) Collection)Mapping)Sequence)Sized)DecimalN)Complex)Any) TYPE_CHECKING)ndarray full_objectobject message_dataSequence[tuple[str, str, str]]number_of_elementsint different_idsSequence[object] max_abs_difffloat max_rel_diffreturn list[str]c t|}|ddgd |D]x\}}} t dt| d<t dt| d<t dt|  d<ydt|d|dd |d |g fd |Dz} | S) Nr)IndexObtainedExpected)rrrz(comparison failed. Mismatched elements: z / :zMax absolute difference: zMax relative difference: c hg|].\}}}|ddd|ddd|dd/S)z#_compare_approx..(ss    'GXx ^Yq\^^^^x^)A,^^^^H^yYZ|^^^^   )listinsertmaxlen) r rrrrr message_listindexr&r' explanationr(s @r)_compare_approxr3s %%L<=== I%188!x9Q<U44 ! 9Q<X77 ! 9Q<X77 ! _3}3E3E__J\___2L222L22    +7    K r+cdeZdZdZdZdZddd Zdd ZddZddZ dZ dZ ddZ ddZ dZddZdS) ApproxBasezhProvide shared utilities for making approximate comparisons between numbers or sequences of numbers.NdFnan_okboolrNonecjd}||_||_||_||_|dS)NT)r'absrelr7 _check_type)selfr'r<r;r7__tracebackhide__s r)__init__zApproxBase.__init__:s<     r+strctNNotImplementedErrorr>s r)__repr__zApproxBase.__repr__Bs!!r+ other_sider rcdd|d|gS)Nzcomparison failedz Obtained: z Expected: r#)r>rHs r) _repr_comparezApproxBase._repr_compareEs%  % % %     r+c`tfd|DS)Nc3PK|] \}}||kV!dSrC_approx_scalar)r$axr>s r) z$ApproxBase.__eq__..MsK  ,0AqA$$Q'' '      r+)all_yield_comparisonsr>actuals` r)__eq__zApproxBase.__eq__LsI    484K4KF4S4S      r+c$d}td)NTzVapprox() is not supported in a boolean context. Did you mean: `assert a == approx(b)`?)AssertionError)r>r?s r)__bool__zApproxBase.__bool__Qs  e   r+c||k SrCr#rTs r)__ne__zApproxBase.__ne__ZsdN##r+ ApproxScalarct|tr"t||j|j|jSt ||j|j|jS)N)r<r;r7) isinstancer ApproxDecimalr<r;r7r\)r>rPs r)rNzApproxBase._approx_scalar]sO a ! ! T dht{SSS SA48$+NNNNr+ct)zoYield all the pairs of numbers to be compared. This is used to implement the `__eq__` method. rDrTs r)rSzApproxBase._yield_comparisonsbs "!r+cdS)z.vs.CC2/266CCCCCCr+c0g|]}t|Sr#rorqs r)r*z+_recursive_sequence_map..xs$;;;2'2..;;;r+)r^r,tupletype_is_sequence_like)rsrPseq_types` r)rprprs!dE]##77xCCCCCCCCCC 1  ;;;;;;;;qtt r+c:eZdZdZd dZd dZdfd Zd ZxZS) ApproxNumpyzHPerform approximate comparisons where the expected value is numpy array.rrAcft|j|j}d|dS)Napprox())rprNr'tolist)r> list_scalarss r)rGzApproxNumpy.__repr__s:.  !5!5!7!7  +****r+rHndarray | list[Any]rcddl}ddl}dd|jj}t |j|jt|J|jkrd d |d jgS|jj}|j }|j }g}|j d |DD]} | } | } | | krjt| j| z } t|| }| d kr|j }n t|| t| z }| | fd|D} t|j| ||||S)Nr nested_list list[Any]nd_indextuple[Any, ...]rr c$|}|D] }||} |S)z Helper function to get the value out of a nested list, given an n-dimensional index. This mimics numpy's indexing, but for raw nested python lists. r#)rrvalueis r)get_value_from_nested_listz=ApproxNumpy._repr_compare..get_value_from_nested_lists(%E ! !aLr+z3Impossible to compare arrays with different shapes.zShapes:  and c34K|]}t|VdSrC)range)r$rs r)rQz,ApproxNumpy._repr_compare..s((J(Jaq(J(J(J(J(J(Jr+c g|]B}t|t|t|fCSr#rA)r$r1approx_side_as_seqrother_side_as_arrays r)r*z-ApproxNumpy._repr_compare..sj    E ../BEJJKK../A5IIJJ    r+)rrrrrr ) itertoolsmathr'shaperprNr~_as_numpy_arraysizeinfproductr;r.appendr3)r>rHrrnp_array_shaperrrrr1 approx_value other_valueabs_diffrrrrs @@@r)rJzApproxNumpy._repr_compares     ,4  !5!5!7!7   .j99"... 06 6 6EK>KK0C0IKK  "]/y y  &Y&(J(J>(J(J(JK , ,E556H%PPL445H%PPK{**|4{BCC"<:: #%%#'8LL#&|XK@P@P5P#Q#QL$$U+++      '     M         r+r8cJddl}||s= ||}n&#t$r}t d|d|d}~wwxYw||s|j|jjkrdSt|S)Nrzcannot compare 'z' to numpy.ndarrayF) numpyisscalarasarray Exception TypeErrorrr'superrV)r>rUnpe __class__s r)rVzApproxNumpy.__eq__s{{6"" V VF++ V V V M6 M M MNNTUU V{{6"" v|t}7J'J'J5ww~~f%%%s2 AAAc#Kddl}||rG||jjD]%}||j|fV&dS||jjD]=}|||j|fV>dS)Nr)rrndindexr'ritem)r>rUrrs r)rSzApproxNumpy._yield_comparisonss ;;v   @ZZ 344 6 6dmA.335555555 6 6ZZ 344 @ @Qinn&& a(8(=(=(?(?????? @ @r+rc)rHrrrrd) rfrgrhrirGrJrVrS __classcell__rs@r)rzrz}sRR++++ > > > > @&&&&&& @ @ @ @ @ @ @r+rzcBeZdZdZddZddZdfd Zd Zdd ZxZ S) ApproxMappingzyPerform approximate comparisons where the expected value is a mapping with numeric values (the keys can be anything).rrAcVdfdjDdS)Nr|cBi|]\}}||Sr#rMr$kvr>s r) z*ApproxMapping.__repr__..s-XXX$!QAt22155XXXr+r})r'itemsrFs`r)rGzApproxMapping.__repr__s7^XXXX$-BUBUBWBWXXX^^^^r+rHMapping[object, float]rc ddl}fdjD t }|j }|j }g}t D]\\}}} || kr|jy| w t|t|j| z }|jdkr|j}n-t|t|j| z |jz }n#t$rYnwxYw| | fd|D} tj| ||||S)NrcBi|]\}}||Sr#rMrs r)rz/ApproxMapping._repr_compare..s:   *.!QAt""1%%   r+rcg|]:}t|t|t|f;Sr#r)r$keyapprox_side_as_maprHs r)r*z/ApproxMapping._repr_compare..sP   XXs:c?++S1CC1H-I-I J   r+) rr'rr/rzipvaluesr.r;ZeroDivisionErrorrr3) r>rHrrrrr approx_keyrrrrs `` @r)rJzApproxMapping._repr_compares     26-2E2E2G2G   !!344y y  7:  $ $ & & (9(9(;(;8 8  1 1 3 &Z {**(49P'*(#l.Ck.Q*R*R(( (0C77+/8LL+. , #%1%:[%H&2&;%<!"!",,L-$$Z000     $    M         sA%D D  D r8c t|t|jkrdSn#t$rYdSwxYwt |SNF)setkeysr'AttributeErrorrrVr>rUrs r)rVzApproxMapping.__eq__s} 6;;==!!S););)=)=%>%>>>u?   55 ww~~f%%%sA A AAc#pK|jD]}|||j|fVdSrC)r'r)r>rUrs r)rSz ApproxMapping._yield_comparisons%sL##%% . .A)T]1-- - - - - . .r+r9c d}|jD]d\}}t|t|jr=d}t |||t j|jedS)NTz[pytest.approx() does not support nested dictionaries: key={!r} value={!r} full mapping={})r'rr^rvrformatpprintpformat)r>r?rrmsgs r)r=zApproxMapping._check_type)s ---// W WJC%dm!4!455 Wt 3v~dm7T7T U UVVV W W Wr+rc)rHrrrrdre rfrgrhrirGrJrVrSr=rrs@r)rrs77____. . . . `&&&&&&...WWWWWWWWr+rcBeZdZdZddZddZdfd Zd Zdd ZxZ S)ApproxSequenceLikezRPerform approximate comparisons where the expected value is a sequence of numbers.rrActj}|ttfvrt}d|fdjDdS)Nr|c3BK|]}|VdSrCrM)r$rPr>s r)rQz.ApproxSequenceLike.__repr__..8s1!P!PQ$"5"5a"8"8!P!P!P!P!P!Pr+r})rvr'rur,)r>rxs` r)rGzApproxSequenceLike.__repr__4sX && E4= ( (HU!P!P!P!P$-!P!P!PPPUUUUr+rHSequence[float]rc ddl}t|jtkr)ddt|jdtgSt|j|j t }|j }|j }g}t t D]\}\}} || kr| t|j| z } t|| }| dkr|j}n1t|| t| z }n#t$rYnwxYw| | fd|D} t|j| ||||S)Nrz1Impossible to compare lists with different sizes.z Lengths: rrcg|]:}t|t|t|f;Sr#r)r$rrrHs r)r*z4ApproxSequenceLike._repr_compare..YsP   VVSA''-?-B)C)C D   r+) rr/r'rprNr enumeraterr;r.rrr3) r>rHrrrrrrrrrrrs ` @r)rJz ApproxSequenceLike._repr_compare:s t}  Z 0 0CFC ..FFS__FF  5T5H$-XX !344y y  .7 "J / // /  ( ( *A* k{** V"<#8;#FGGH#&|X#>#>L #c))'+x '*<C DTDT9T'U'U !D$$Q'''     "    M         s<'D DDr8c t|t|jkrdSn#t$rYdSwxYwt|Sr)r/r'rrrVrs r)rVzApproxSequenceLike.__eq__gse 6{{c$-0000u1   55 ww~~f%%%s %+ 99c,t||jSrC)rr'rTs r)rSz%ApproxSequenceLike._yield_comparisonsos64=)))r+r9c d}t|jD]d\}}t|t|jr=d}t |||t j|jedS)NTz]pytest.approx() does not support nested data structures: {!r} at index {} full sequence: {})rr'r^rvrrrr)r>r?r1rPrs r)r=zApproxSequenceLike._check_typers !$-00 U UHE1!T$-0011 Uv 1eV^DM5R5R S STTT U U Ur+rc)rHrrrrdrerrs@r)rr1s\\VVVV + + + + Z&&&&&&***UUUUUUUUr+rcZeZdZUdZdZded<dZded<dd Zdd Zd Z e d Z d S)r\zLPerform approximate comparisons where the expected value is a single number.g-q=zfloat | DecimalDEFAULT_ABSOLUTE_TOLERANCEgư>DEFAULT_RELATIVE_TOLERANCErrAc8t|jtsat|jttfr@t jt|jpt|jtrt|jS d|j cxkrdkr nn |j d}n |j d}t|jtr*|jj rt j|j s|dz }n#t$rd}YnwxYw|jd|S)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°``. gMbP?g@@nz.1eu ∠ ±180°z???u ± ) r^r'r8r rrisinfr;rA toleranceimag ValueError)r>vetted_tolerances r)rGzApproxScalar.__repr__sA t}d + + &t}w.@AA &z#dm,,O 4=$0O0OPP & t}%% % %t~+++++++++&*n#8#8  &*n#:#: 4='22 3M& 3 4>22 3 !N2  % % %$    %-77%5777sA,C>> D  D r8cd d}t|}| tfd|jDS|jr ||sdS|jkrd S|js=t jt t frt |t t fsdStjtjr(j o tjt|Stj tjrdStj|z j k}|S) ziReturn whether the given value is equal to the expected value within the pre-specified tolerance.valr rr8ct|trdS ddl}t||jS#t$rYdSwxYw)NTrF)r^r8rbool_ ImportError)rrs r)is_boolz$ApproxScalar.__eq__..is_bools^#t$$ t """"!#rx000   uu s2 AANc3BK|]}|VdSrC)rV)r$rOr>s r)rQz&ApproxScalar.__eq__..s-<rUrrresults` r)rVzApproxScalar.__eq__s\    "&))  <<<.set_defaults 117 2r+rz&absolute tolerance can't be negative: z absolute tolerance can't be NaN.Nz&relative tolerance can't be negative: z relative tolerance can't be NaN.) r;rrrrr<rr'r.)r>rabsolute_tolerancerelative_tolerances r)rzApproxScalar.tolerances$ 3 3 3 )[43RSS  ! !M9KMM  :( ) ) A?@@ @ 8 x#)))[ Hd5      ! !M9KMM  :( ) ) A?@@ @%'9:::r+rcrd) rfrgrhrir__annotations__rrGrVrlpropertyrr#r+r)r\r\zsVV387777266666!8!8!8!8F6666rH ,;,;X,;,;,;r+r\c>eZdZdZedZedZdS)r_zFPerform approximate comparisons where the expected value is a Decimal.z1e-12z1e-6N)rfrgrhrirrrr#r+r)r_r_s4PP!(!1!1!(r+r_Fr7r8cd}t|trt}nt|trt}nt |rt |}t}nct|rt}nLt|tr0t|ttfsd|}t|t}|||||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 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``. Tz:pytest.approx() only supports ordered sequences, but got: )r^rr_rr_is_numpy_arrayrrzrwrrrAbytesrr\)r'r<r;r7r?clsrs r)approxrs`(G$$  - Hg & &   " " "8,, 8 $ $  Hj ) )*XU|2T2TW8WWnn 3xc6 * **r+r'ct|do1t|tot|ttf S)N __getitem__)hasattrr^rrAr)r's r)rwrws?-(( 3 x ' ' 38c5\22 2r+objc$t|duS)zr Return true if the given object is implicitly convertible to ndarray, and numpy is already imported. N)r)rs r)rrs 3  t ++r+ndarray | Nonectjd}|c||rdSt ||jr|St |dst ddr||SdS)z Return an ndarray if the given object is implicitly convertible to ndarray, and numpy is already imported, otherwise None. rN __array__r__array_interface__)sysmodulesgetrr^r rr)rrs r)rr s koog&&B ~ ;;s   #4 RZ ( ( #J S+ & & #'%9N*O*O #::c?? " 4r+)r rrrrrrrrrrrrrrb)r7r8rr5)r'rrr8)rrrr8)rrrr) __future__rcollections.abcrrrrdecimalrrnumbersr rrtypingr r rr r3r5rprzrrr\r_rrwrrr#r+r)r s""""""&&&&&&######$$$$$$!!!!!!   :8K8K8K8K8K8K8K8K@e@e@e@e@e@*e@e@e@PIWIWIWIWIWJIWIWIWXFUFUFUFUFUFUFUFURS;S;S;S;S;:S;S;S;l11111L111a+a+a+a+a+H,,,,r+