refactor: rename the trait for comouting circuit values in legacy to match the same modification in kernel

legacy/src/lcr_connector/common.py

@@ -270,8 +270,8 @@ class Circuit:
             raise LcrConnException("No third device")
 
 
-class CircuitValueTrait:
+class CircuitCalculator:
-    """The trait for handful circuit computation"""
+    """The bunch of functions for handful circuit computation"""
 
     __device_kind: DeviceKind
     """The kind of the device"""

legacy/src/lcr_connector/query.py

@@ -2,7 +2,7 @@ import enum
 from functools import cached_property
 from dataclasses import dataclass
 from typing import Iterable, Iterator
-from .common import DeviceKind, Circuit, CircuitValueTrait
+from .common import DeviceKind, Circuit, CircuitCalculator
 
 
 class ResponsePriority(enum.Enum):
@@ -60,12 +60,12 @@ class ResponseItem:
 
     __circuit: Circuit
     """The circuit of the response item."""
-    __cv_trait: CircuitValueTrait
+    __ccalc: CircuitCalculator
     """The trait for computing circuit values."""
 
-    def __init__(self, circuit: Circuit, cv_trait: CircuitValueTrait) -> None:
+    def __init__(self, circuit: Circuit, ccalc: CircuitCalculator) -> None:
         self.__circuit = circuit
-        self.__cv_trait = cv_trait
+        self.__ccalc = ccalc
 
     @property
     def circuit(self) -> Circuit:
@@ -92,7 +92,7 @@ class ResponseItem:
 
         :return: The value.
         """
-        return self.__cv_trait.value(self.__circuit)
+        return self.__ccalc.value(self.__circuit)
 
     @cached_property
     def difference(self) -> float:
@@ -104,7 +104,7 @@ class ResponseItem:
 
         :return: The signed difference.
         """
-        return self.__cv_trait.difference(self.__circuit, value=self.value)
+        return self.__ccalc.difference(self.__circuit, value=self.value)
 
     @cached_property
     def unsigned_difference(self) -> float:
@@ -113,7 +113,7 @@ class ResponseItem:
 
         :return: The unsigned difference.
         """
-        return self.__cv_trait.unsigned_difference(
+        return self.__ccalc.unsigned_difference(
             self.__circuit, difference=self.difference
         )
 
@@ -127,7 +127,7 @@ class ResponseItem:
 
         :return: The signed relative difference.
         """
-        return self.__cv_trait.relative_difference(
+        return self.__ccalc.relative_difference(
             self.__circuit, difference=self.difference
         )
 
@@ -138,7 +138,7 @@ class ResponseItem:
 
         :return: The unsigned relative difference.
         """
-        return self.__cv_trait.unsigned_relative_difference(
+        return self.__ccalc.unsigned_relative_difference(
             self.__circuit, relative_difference=self.relative_difference
         )
 
@@ -158,9 +158,9 @@ class Response:
     """The sorted items by priority and difference."""
 
     def __init__(self, request: Request, candidates: Iterable[Circuit]) -> None:
-        cv_trait = CircuitValueTrait(request.device_kind, request.target_value)
+        ccalc = CircuitCalculator(request.device_kind, request.target_value)
         self.__device_kind = request.device_kind
-        self.__sorted_items = list(ResponseItem(item, cv_trait) for item in candidates)
+        self.__sorted_items = list(ResponseItem(item, ccalc) for item in candidates)
 
         # Sort by different strategy
         match request.response_priority:

legacy/src/lcr_connector/resolver/bfs.py

@@ -4,7 +4,7 @@ from typing import Iterable, Iterator
 from functools import cached_property
 from .common import Resolver
 from ..dataset import DatasetCollection, Dataset
-from ..common import Circuit, DeviceKind, JointKind, CircuitValueTrait
+from ..common import Circuit, DeviceKind, JointKind, CircuitCalculator
 from ..query import Request, Response
 
 
@@ -15,12 +15,12 @@ class BfsItem:
 
     __circuit: Circuit
     """The circuit represented by this item."""
-    __cv_trait: CircuitValueTrait
+    __ccalc: CircuitCalculator
     """The trait for computing circuit values."""
 
-    def __init__(self, circuit: Circuit, cv_trait: CircuitValueTrait):
+    def __init__(self, circuit: Circuit, ccalc: CircuitCalculator):
         self.__circuit = circuit
-        self.__cv_trait = cv_trait
+        self.__ccalc = ccalc
 
     @property
     def circuit(self) -> Circuit:
@@ -33,7 +33,7 @@ class BfsItem:
 
         :return: The computed value.
         """
-        return self.__cv_trait.value(self.__circuit)
+        return self.__ccalc.value(self.__circuit)
 
     @cached_property
     def unsigned_difference(self) -> float:
@@ -42,7 +42,7 @@ class BfsItem:
 
         :return: The unsigned difference.
         """
-        return self.__cv_trait.unsigned_difference(self.__circuit, value=self.value)
+        return self.__ccalc.unsigned_difference(self.__circuit, value=self.value)
 
 
 class ResultBucket(Iterable[BfsItem]):
@@ -223,10 +223,10 @@ class BfsResolver(Resolver):
 
     @staticmethod
     def __bfs_iteration(
-        dataset: Dataset, cv_trait: CircuitValueTrait
+        dataset: Dataset, ccalc: CircuitCalculator
     ) -> Iterator[BfsItem]:
         return (
-            BfsItem(circuit, cv_trait)
+            BfsItem(circuit, ccalc)
             for circuit in chain(
                 BfsResolver.iter_one_device_circuit(dataset),
                 BfsResolver.iter_two_devices_circuit(dataset),
@@ -247,8 +247,8 @@ class BfsResolver(Resolver):
 
         # Iterate circuit item one by one
         bucket = ResultBucket(request.count_limit)
-        cv_trait = CircuitValueTrait(request.device_kind, request.target_value)
+        ccalc = CircuitCalculator(request.device_kind, request.target_value)
-        for item in BfsResolver.__bfs_iteration(dataset, cv_trait):
+        for item in BfsResolver.__bfs_iteration(dataset, ccalc):
             # If circuit absolute difference is out of tolerance, skip it directly.
             if item.unsigned_difference > request.tolerance:
                 continue

legacy/src/lcr_connector/resolver/lut.py

@@ -3,7 +3,7 @@ from itertools import chain
 from .common import Resolver
 from .bfs import BfsResolver
 from ..dataset import DatasetCollection, Dataset
-from ..common import Circuit, DeviceKind, CircuitValueTrait
+from ..common import Circuit, DeviceKind, CircuitCalculator
 from ..query import Request, Response
 
 
@@ -91,7 +91,7 @@ class LutResolver(Resolver):
         # target.  This guarantees items are visited in strictly increasing
         # difference order, so the first N items within tolerance are exactly
         # the N best matches.
-        cv_trait = CircuitValueTrait(request.device_kind, target)
+        ccalc = CircuitCalculator(request.device_kind, target)
         while left >= 0 or right < len(lut):
             if len(bucket) >= count_limit:
                 break
@@ -102,11 +102,11 @@ class LutResolver(Resolver):
                 go_left = True
             else:
                 left_instance = lut[left]
-                left_diff = cv_trait.unsigned_difference(
+                left_diff = ccalc.unsigned_difference(
                     left_instance.circuit, value=left_instance.value
                 )
                 right_instance = lut[right]
-                right_diff = cv_trait.unsigned_difference(
+                right_diff = ccalc.unsigned_difference(
                     right_instance.circuit, value=right_instance.value
                 )
                 go_left = left_diff <= right_diff
@@ -118,7 +118,7 @@ class LutResolver(Resolver):
                 item = lut[right]
                 right += 1
 
-            diff = cv_trait.unsigned_difference(item.circuit, value=item.value)
+            diff = ccalc.unsigned_difference(item.circuit, value=item.value)
             # Since the LUT is sorted, values on each side only move further
             # from target as we advance.  Once one side exceeds tolerance,
             # the rest of that side is guaranteed out of range — disable it.