Python3 Int16 wrapper class proposal for the SCI transpolar

i16.py

class Int16:
    def __init__(self, value):
        self.value = value & 0xFFFF  # Always keep it 16-bit

    def _wrap(self, result):
        return Int16(result)

    def signed(self):
        return self.value if self.value < 0x8000 else self.value - 0x10000

    def unsigned(self):
        return self.value

    def post_inc(self):
        old = self.value
        self.value = (self.value + 1) & 0xFFFF
        return Int16(old)

    def post_dec(self):
        old = self.value
        self.value = (self.value - 1) & 0xFFFF
        return Int16(old)

    def __repr__(self):
        return f"Int16({self.signed()})"

    def __int__(self):
        return self.signed()

    def __index__(self):
        return self.value  # for things like list indexing

    def __bool__(self):
        return self.value != 0

    # Arithmetic operators
    def __add__(self, other):
        return self._wrap(self.value + int(other))

    def __sub__(self, other):
        return self._wrap(self.value - int(other))

    def __mul__(self, other):
        return self._wrap(self.value * int(other))

    def __floordiv__(self, other):
        return self._wrap(self.signed() // int(other))

    def __mod__(self, other):
        return self._wrap(self.signed() % int(other))

    def __pow__(self, other):
        return self._wrap(pow(self.value, int(other)))

    # Bitwise operators
    def __and__(self, other):
        return self._wrap(self.value & int(other))

    def __or__(self, other):
        return self._wrap(self.value | int(other))

    def __xor__(self, other):
        return self._wrap(self.value ^ int(other))

    def __lshift__(self, other):
        return self._wrap(self.value << int(other))

    def __rshift__(self, other):
        return self._wrap(self.value >> int(other))

    def __invert__(self):
        return self._wrap(~self.value)

    def __neg__(self):
        return self._wrap(-self.signed())

    # Reverse operations for right-hand side Int16
    __radd__ = __add__
    __rsub__ = lambda self, other: self._wrap(int(other) - self.value)
    __rmul__ = __mul__
    __rfloordiv__ = lambda self, other: self._wrap(int(other) // self.signed())
    __rmod__ = lambda self, other: self._wrap(int(other) % self.signed())
    __rand__ = __and__
    __ror__ = __or__
    __rxor__ = __xor__
    __rlshift__ = lambda self, other: self._wrap(int(other) << self.value)
    __rrshift__ = lambda self, other: self._wrap(int(other) >> self.value)

    # Comparison operators
    def __eq__(self, other):
        return self.signed() == int(other)

    def __lt__(self, other):
        return self.signed() < int(other)

    def __le__(self, other):
        return self.signed() <= int(other)

    def __gt__(self, other):
        return self.signed() > int(other)

    def __ge__(self, other):
        return self.signed() >= int(other)