How does pytest.approx accomplish its magic?

Question

The pytest approx function seems really, cool, and as they say in their documentation it uses a really intuitive syntax:

>>> from pytest import approx
>>> 0.1 + 0.2 == approx(0.3)
True

>>> 1 + 1e-8 == approx(1)
True

But how does this actually work? In the first example, let's say the left side reduces to something like 0.29999..., so how can I have something on the right side that evaluates to being equal to it? Does the approx function somehow know how to look at the lvalue of the == operator? The fact that approx actually works seems like pure sorcery, can someone explain how it accomplishes its neat little trick?

Answer 1

This is a standard datamodel hook into a custom __eq__.

The simplified example below should clarify the "sorcery" for you.

>>> class MyObj: 
...     def __eq__(self, other): 
...         print(self, "is being compared with", other) 
...         return "potato" 
...
>>> obj = MyObj()   
>>> 0.1 + 0.2 == obj
<__main__.MyObj object at 0xcafef00d> is being compared with 0.30000000000000004
'potato'

Note that float.__eq__ will get the first attempt at handling this comparison. The behavior shown above, and also for approx(0.3), crucially relies on the fact that float has explicitly "opted out" of comparing with MyObj instances. It does this by returning a special value NotImplemented:

>>> (0.1+0.2).__eq__(obj)
NotImplemented

For the actual pytest implementation, look in python_api.py::ApproxScalar.

Answer 2

From the source code I could find that they create corresponding Approx version of the classes. For example, they have ApproxDecimal, ApproxScalar, ApproxMapping and so on. The approx function checks the type of the value you pass and then assigns it a corresponding approximate class that they have defined.

So when you enter:

0.1 + 0.2 == approx(0.3)

the approx changes it to:

0.1 + 0.2 == ApproxDecimal(0.3)

Now these Approx classes implement corresponding __eq__() and __repr__() functions that help python perform the comparison. Hence they are able to define the logic for approximate matching within these Approximate classes.