Is there a standard class that implements all the int-like magic methods by calling int(self)?

Please note: I have made edits since some of these responses were given, due to my bad wording. Blame me. Thanks to everyone for putting up with me.

I am writing a class that has int-like properties.

It implements the __int__ method.

I'd like to implement all the magic methods that ints have: __add__, __and__, __rshift__ etc., by applying the same function on int(self).

For example:

  def __lshift__(self, other):
    return int(self) << other

  def __bool__(self):
    return bool(int(self))

  # and so forth, for about 40 more methods.

Is there an object that will do this for me? It seems like this would be a common pattern.

I tried with class MyClass(int), but this did not allow me to override __int__

My class is not an int; I want it to be able to be treated as an int.

Or should I be doing this some other way?

I am trying to simulate FPGA wires & registers - the value will change dynamically.

For example, if inst.wire2 is defined as inst.wire1 + 10, then inst.wire2 will always be inst.wire1 + 10; if inst.wire1 changes, inst.wire2 changes with it.

Once complete, almost all access to a given wire or register will be for it's value, so making every reference inst.wire1.value (or self.wire1.value) will clutter the code immensely, with no advantage.

TO CLARIFY: if someone treats the property as an int (e.g. by adding a number to it), the result should be a regular, real, actual int, with no magic stuff.

The approach I would use would be to split your wire class into several related classes: an abstract superclass that implements all the operators, a class that represents an input wire, and two classes that represent binary and unary operators.

Here's a start:

from dataclasses import dataclass
from abc import ABC, abstractmethod
from collections.abc import Callable
import operator

class Wire(ABC):
    def __add__(self, other: 'Wire | int') -> 'Wire':
        return BinopWire(self, other, operator.add)

    def __radd__(self, other: 'Wire | int') -> 'Wire':
        return BinopWire(other, self, operator.add)

    # ...

    def __lshift__(self, other: 'Wire | int') -> 'Wire':
        return BinopWire(self, other, operator.lshift)

    def __rlshift__(self, other: 'Wire | int') -> 'Wire':
        return BinopWire(other, self, operator.lshift)

    def __neg__(self) -> 'Wire':
        return UnopWire(self, operator.neg)

    def __inv__(self) -> 'Wire':
        return UnopWire(self, operator.inv)

    @abstractmethod
    def __int__(self) -> int:
        ...

    def __bool__(self) -> bool:
        return bool(int(self))

@dataclass
class InputWire(Wire):
    value: int

    def __int__(self) -> int:
        return self.value

@dataclass
class BinopWire(Wire):
    left: Wire | int
    right: Wire | int
    op: Callable[[int, int], int]

    def __int__(self) -> int:
        return self.op(int(self.left), int(self.right))

@dataclass
class UnopWire(Wire):
    arg: Wire | int
    op: Callable[[int], int]

    def __int__(self) -> int:
        return self.op(int(self.arg))


wire1 = InputWire(7)
wire2 = wire1 + 7
print(int(wire2))
wire3 = -wire2
wire1.value = 3
print(int(wire3))

This approach allows you to construct wires that can be evaluated multiple times, with different inputs.

Ok, I've figured out an answer (not necessarily the best one, but it works).

There are two parts to this.

One part is how to calculate the values on demand. This is done using the __get__ method.

The other part is to create a class which inherits from __int__ (thanks @Augusto Vasques for pointing me at that!).

In part, my code reads something like:

import time

class LikeInt(int):
    # if you want to add arguments to __init__,
    # these same arguments are passed to __new__
    # so you have to ignore them in __new__
    # not needed here, as I'm not adding any arguments,
    # but it would look like this.
    #def __new__(cls, x, *args, **kwargs):
    #  return int.__new__(cls, x)

    def something(self):
        print("something!")

class Wire(object):
  def __init__(self, function):
    self.__function__ = function

  def __get__(self, pinstance = None, pclass = None):
    if pinstance == None:
      raise AttributeError()

    value = self.__function__(pinstance)
    print("turns out ", self.__function__.__name__, " is ", value, "right now")

    return LikeInt(value)

def AutoDecorator(Class, **kwargs):
  def AutoDecorate(function):
    return Class(function = function, **kwargs)
  return AutoDecorate

class MyCircuit(object):
  @AutoDecorator(Class = Wire)
  def myfirstwire(self):
    return int(time.time()) # this is just an example of a changing value

  @AutoDecorator(Class = Wire)
  def mysecondwire(self):
    return self.myfirstwire + 1

inst = MyCircuit()

# this will trigger inst.myfirstwire._get_, which creates a LikeInt.
inst.myfirstwire.something()

# this will trigger inst.mysecondwire._get_; this will run the function, which then triggers inst.myfirstwire.__get__
print(inst.mysecondwire + 2)

time.sleep(5)
print(inst.mysecondwire + 2)

This is, of course, a massive simplification; it doesn't include register etc., but it meets the criteria of the question:

• inst.myfirstwire and inst.mysecondwire implement add/and/rshift etc., without me having to code them one-by-one
• mysecondwire will always be one more than myfirstwire (at any given instant)
• you can print(inst.mysecondwire + 10)
• when you treat inst.mysecondwire as an int (e.g. by adding a number to it) the result is a regular, real, actual int, with no magic stuff.

In case someone else uses this,