Automatically defined numeric operators in Python3

You can write your own mixin class or decorator that does this, similarly to the way collections.abc.Sequence implements a bunch of Sequence methods on top of a handful that you write manually, or functools.total_ordering implements a bunch of comparison methods for you. (If you're wondering how to decide which one to use: if the code has to examine your class before modifying it, as with total_ordering, your mixin would need a custom metaclass, so a decorator is easier. Otherwise, a mixin is usually simpler.)

There are dozens of implementations of this idea floating around PyPI and the ActiveState recipes and random blog posts and GitHub repos. But the problem isn't quite generalizable to turn a solution into a widely-used library.

As for the specific case you want—an object that acts like a mutable int, and implements it on the basis of its __int__ method—I think that specific case just doesn't come up often enough that anyone has sat down and written it.

Anyway, getting all of this right—including things like 3.0 + x and x + 3.0—is a bit of a pain.

Implementing the arithmetic operations in the numbers documentation explains exactly what you want to do to get it right.

It also contains an explanation of the source code used by the fractions library to reduce the boilerplate and repetition of defining all of these methods on fraction.Fraction, which is very handy.

The only problem with all of that is that it's written for immutable numeric types, not mutable ones. So, if you want to use it, you'll need to modify it, with an operator_fallback function that builds and returns forward, reverse, inplace instead of just forward, reverse.

However, your case is simpler than Fraction, so you can simplify the operator-function-creating methods, like this:

def _operator_fallbacks(op, sym):
    def forward(a, b):
        result = op(int(a), b)
        if isinstance(result, int): result = type(a)(result)
        return result
    forward.__name__ = '__' + op.__name__ + '__'
    forward.__doc__ = f"a {sym} b"

    def reverse(b, a):
        result = op(a, int(b))
        if isinstance(result, int): result = type(b)(result)
        return result
    reverse.__name__ = '__r' + op.__name__ + '__'
    reverse.__doc__ = f"a {sym} b"

    def inplace(a, b):
        # If you want to work via __int__ rather than by digging
        # into the internals, you can't delegate += to +=, you
        # have to implement it via some kind of set method.
        a.set(op(int(a), b))
        return a
    inplace.__name__ = '__i' + op.__name__ + '__'
    inplace.__doc__ = f'a {sym}= b'

    return forward, reverse, inplace

__add__, __radd__, __iadd__ = _operator_fallbacks(operator.add, '+')
__sub__, __rsub__, __isub__ = _operator_fallbacks(operator.sub, '-')

You might want to consider isinstance(result, numbers.Integral). You might also want to make your class a subtype of numbers.Integral. If you do both, be careful about how you construct them, so you don't end up with an Int(Int(Int(5))) instead of an Int(5).

If you wanted to generalize this into a mixin that can be used for mutable int, float, complex, Decimal, Fraction, etc. types, you could just add a get method that all of your types have to implement, instead of relying on __int__. Although you'd have to think through the conversion issues (int is easy, being on the base of the numeric tower).