# Wrapping integers in Python with Metaclassing

I often require a wrapping integer type in Python, by which I actually mean a subclass of int where all operations are performed modulo some constant number $N$. There are two main use cases for this: 1. Working in a finite field for some cryptographic stuff, or solving problems on [Project Euler](https://projecteuler.net/about). 2. Having Python integers behave like machine registers (8, 16, 32, 64, even 128 bits - you name it.) I decided to solve this once and for all and wrote the integer wrapper class to end all integer wrapper classes. I also managed to keep it rather compact by using *»gasp«* metaclassing. More on that later. Using wrap, you can create new wrapped types like this:
In : class uint32(wrap, bits=32, hexrep=True): pass

In : a = uint32(0xC0C4C01A)

In : a
Out: 0xc0c4c01a

In : a ** 0x00F
Out: 0x2a028000

The hexrep parameter controls whether you want the numbers display in hex rather than the default base 10 that Python uses. I like this for my use case #2, but often not so much for the finite fields. For example, if $F$ is the field where operations happen modulo the prime number $1000000007$, use this:
In : class F(wrap, mod=1_000_000_007): pass

In : a = F(342_211_123)

In : b = a ** -1

In : a * b
Out: 1

In : a / b == a * a
Out: True

In : a // b == a * a
Out: False

The division operator / will use modular inverses while the floor division operator // will work as usual. This is actually a bit of a gotcha, because sometimes you can perform a modular inversion modulo $2^{32}$ and the result is, of course, completely different from floor division:
In : a
Out: 0xc0c4c01a

In : a ** 0x00F
Out: 0x2a028000

In : a / 13
Out: 0x49e7c002

In : a // 13
Out: 0xed40ec6

So, if you hate that, change it. I wanted this to solve two use cases at once, so I am keeping it. Here's the code:
class wrapped(type):
def __new__(cls, name, bases, nmspc, mod=None, bits=None, hexrep=False, signed=False):
assert int in bases.__mro__
if None not in (mod, bits) and 1 << bits != mod:
raise ValueError('incompatible mod and bits argument.')
mod = mod or bits and 1 << bits
if mod:
for op in 'add', 'and', 'floordiv', 'lshift', 'mod', 'mul', 'or', 'rshift', 'sub', 'xor':
opname = F'__{op}__'
nmspc[F'__r{op}__'] = nmspc[opname] = lambda self, them, op=getattr(int, opname): (
self.__class__(op(self, them)))
nmspc['__rtruediv__'] = nmspc['__truediv__'] = lambda self, them, p=int.__pow__: (
self.__class__(self * p(them, -1, mod)))
nmspc['__pow__'] = lambda self, them, op=int.__pow__: self.__class__(op(self, them, mod))
nmspc['__inv__'] = lambda self, op=int.__invert__: self.__class__(op(self))
nmspc['__neg__'] = lambda self, op=int.__neg__: self.__class__(op(self))
nmspc.update(mod=mod, signed=signed)
if hexrep is True:
nib, up = divmod((mod.bit_length() - 1) - 1, 4)
nib += bool(up)
nmspc['__repr__'] = lambda self: F'{self:#0{nib}x}'
return type.__new__(cls, name, bases, nmspc)

def __call__(cls, value=0, *args, **kwargs):
if isinstance(value, int):
value = value % cls.mod
if cls.signed and (value & (cls.mod >> 1)):
value -= cls.mod
return type.__call__(cls, value)
return cls(int(value, *args, **kwargs))

class wrap(int, metaclass=wrapped):
pass

I'll explain my choices a little bit: When you create a new integer type, you have to re-implement all of the relevant [standard operators](https://docs.python.org/3/library/operator.html), even though your modification will always be conceptually the same: Perform the operation as the int class would do it, then take the result modulo your given modulus. The metaclass wrapped automates this. When a class of type wrapped is defined, then all of these necessary wrappers are generated by the metaclass and adds them to the class definition. The class wrap is a convenience class to facilitate easier creation of new classes of type wrapped. Fair warning: **Python 3.8** is required for the calculation of multiplicative inverses, because that's when the pow function became able to do this out of the box.