refactor: refactoring old code

legacy/resolver/common.py

@@ -0,0 +1,102 @@
+import enum
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Iterator
+from ..common import DeviceKind, Circuit
+
+
+class ResultPriority(enum.Enum):
+    """
+    The priority of the result.
+    """
+
+    LESS_DEVICES = enum.auto()
+    """Less devices is the first priority."""
+    MORE_ACCURACY = enum.auto()
+    """More accuracy is the first priority."""
+
+
+@dataclass
+class ResolverRequest:
+    """
+    The request object for the resolver.
+    """
+
+    device_kind: DeviceKind
+    """The kind of device to resolve."""
+    target_value: float
+    """The target value of the device."""
+    tolerance: float
+    """The tolerance of the device."""
+    result_priority: ResultPriority
+    """The priority of the result."""
+    count_limit: int
+    """The limit of the count of results."""
+
+
+class ResolverResult:
+    """
+    The result of the resolver.
+    """
+
+    circuit: Circuit
+    """The circuit of the result."""
+
+    __value_cache: float | None
+    """The cache of the circuit value."""
+    __difference_cache: float | None
+    """The cache of the difference between the target value and the circuit value."""
+    __relative_difference_cache: float | None
+    """The cache of the relative difference between the target value and the circuit value."""
+
+    def __init__(self, circuit: Circuit):
+        self.circuit = circuit
+        self.__value_cache = None
+        self.__difference_cache = None
+        self.__relative_difference_cache = None
+
+    def compute(self, device_kind: DeviceKind) -> float:
+        """
+        Compute the circuit value.
+        """
+        if self.__value_cache is None:
+            self.__value_cache = self.circuit.compute(device_kind)
+        return self.__value_cache
+
+    def difference(self, target_value: float, device_kind: DeviceKind) -> float:
+        """
+        Get the difference between the target value and the circuit value.
+        """
+        if self.__difference_cache is None:
+            self.__difference_cache = abs(
+                target_value - self.circuit.compute(device_kind)
+            )
+        return self.__difference_cache
+
+    def relative_difference(
+        self, target_value: float, device_kind: DeviceKind
+    ) -> float:
+        """
+        Get the relative difference between the target value and the circuit value.
+        """
+        if self.__relative_difference_cache is None:
+            self.__relative_difference_cache = (
+                abs(target_value - self.circuit.compute(device_kind)) / target_value
+            )
+        return self.__relative_difference_cache
+
+    def len_devices(self) -> int:
+        """
+        Get the number of devices in the circuit.
+        """
+        return self.circuit.len_devices()
+
+
+class Resolver(ABC):
+    """
+    Abstract base class for all resolvers.
+    """
+
+    @abstractmethod
+    def resolve(self, request: ResolverRequest) -> Iterator[ResolverResult]:
+        pass