我使用的方法是将wire类拆分为几个相关的类：一个实现所有运算符的抽象超类，一个表示输入线的类，以及两个表示二元和一元运算符的类。
这是一个开始：

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))

这种方法允许您构建可以使用不同输入多次评估的关联。

好吧，我已经想出了一个答案（不一定是最好的，但它的工作）。
这个问题有两个部分。
其中一部分是如何根据需要计算值。这是使用__get__方法完成的。
另一部分是创建一个从__int__继承的类（感谢@Augusto Vasques指出这一点！）.
在某种程度上，我的代码读起来像这样：

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)

当然，这是一个巨大的简化;不包括register等，但符合问题的标准：

• mysfirstwire和inst.mysecondwire实现了add/和/rshift等功能，而我不必逐个编写它们
• mysecondwire总是比myfirstwire多一个（在任何给定的时刻）
• 你可以print(inst.mysecondwire + 10)
• 当你把inst.mysecondwire当作一个int（例如通过向它添加一个数字），结果是一个常规的，真实的，实际的int，没有魔法的东西。

以防别人用这个，