classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -1,12 +1,14 @@
 import abc
 import ast
 import re
-from typing import Any, Dict, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import networkx as nx
 import pydantic
+from pydantic import TypeAdapter
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     parse_expression,
@@ -17,6 +19,9 @@ from classiq.interface.generator.arith.arithmetic_expression_validator import (
 from classiq.interface.generator.arith.arithmetic_result_builder import (
     validate_arithmetic_result_type,
 )
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.uncomputation_methods import UncomputationMethods
 from classiq.interface.generator.expressions.expression_constants import (
@@ -27,8 +32,6 @@ from classiq.interface.generator.expressions.expression_constants import (
 from classiq.interface.generator.function_params import FunctionParams
 from classiq.interface.helpers.custom_pydantic_types import PydanticExpressionStr
 
-from classiq.exceptions import ClassiqValueError
-
 ValidDefinitions: TypeAlias = Union[
     pydantic.StrictInt, pydantic.StrictFloat, RegisterArithmeticInfo
 ]
@@ -36,22 +39,18 @@ ValidDefinitions: TypeAlias = Union[
 
 class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     uncomputation_method: UncomputationMethods = UncomputationMethods.optimized
-    machine_precision: pydantic.NonNegativeInt = number_utils.MAX_FRACTION_PLACES
+    machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
-    definitions: Dict[str, ValidDefinitions]
+    definitions: dict[str, ValidDefinitions]
     qubit_count: Optional[pydantic.NonNegativeInt] = None
 
-    def _get_literal_set(self) -> Set[str]:
+    def _get_literal_set(self) -> set[str]:
         return _extract_literals(self.expression)
 
-    @pydantic.validator("definitions")
+    @classmethod
     def _validate_expression_literals_and_definitions(
-        cls, definitions: Dict[str, ValidDefinitions], values: Dict[str, Any]
-    ) -> Dict[str, ValidDefinitions]:
-        expression = values.get("expression")
-        if expression is None:
-            return definitions
-
+        cls, definitions: dict[str, ValidDefinitions], expression: PydanticExpressionStr
+    ) -> dict[str, ValidDefinitions]:
         literals = _extract_literals(expression)
 
         forbidden = literals.intersection(FORBIDDEN_LITERALS)
@@ -68,12 +67,33 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
             raise ClassiqValueError(f"The following names are undefined: {undefined}")
         return definitions
 
-    @pydantic.root_validator
-    def _validate_expression(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        expression: Optional[str] = values.get("expression")
-        definitions: Optional[Dict[str, ValidDefinitions]] = values.get("definitions")
-        machine_precision: Optional[int] = values.get("machine_precision")
-        if expression is None or definitions is None or machine_precision is None:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_expression(cls, values: Any) -> dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+        expression_adapter: TypeAdapter = TypeAdapter(Optional[PydanticExpressionStr])
+        expression = expression_adapter.validate_python(values.get("expression"))
+        definitions_adapter: TypeAdapter = TypeAdapter(
+            Optional[dict[str, ValidDefinitions]]
+        )
+        definition_dict = values.get("definitions")
+        if (
+            isinstance(definition_dict, list)
+            and len(definition_dict) > 0
+            and isinstance(definition_dict[0], tuple)
+        ):
+            definition_dict = dict(definition_dict)
+        definitions = definitions_adapter.validate_python(definition_dict)
+        machine_precision: Optional[int] = values.get(
+            "machine_precision", DEFAULT_MACHINE_PRECISION
+        )
+        if (
+            expression is None
+            or expression == ""
+            or definitions is None
+            or machine_precision is None
+        ):
             return values
 
         try:
@@ -85,15 +105,39 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         cls._validate_ast_obj(ast_obj)
 
         graph = parse_expression(expression)
-        cls._validate_expression_graph(graph, values)
+        try:
+            cls._validate_expression_graph(graph, values)
+        except ClassiqValueError as e:
+            # This flow was created specifically for inplace Boolean XOR operations like q1 ^ q2.
+            # We can't plug equality in previous stages due to SymPy restrictions.
+            # Note that we don't validate that the expression itself is Boolean (passing non-Boolean expressions
+            # as inplace is currently not supported, so it's a bug).
+            if not e.raw_message == "Expression does not support target assignment":
+                raise
+            ast_parsed_expression = ast.parse(expression)
+            ast_expr = ast_parsed_expression.body[0]
+            if (
+                not isinstance(ast_expr, ast.Expr)
+                or not isinstance(ast_expr.value, ast.BinOp)
+                or not isinstance(ast_expr.value.op, ast.BitXor)
+            ):
+                raise
+            expression = f"({expression}) == 1"
+            graph = parse_expression(expression)
+            cls._validate_expression_graph(graph, values)
+
+        validated_defs = cls._validate_expression_literals_and_definitions(
+            definitions, expression
+        )
+
         validate_arithmetic_result_type(
             graph=graph,
-            definitions=definitions,
+            definitions=validated_defs,
             machine_precision=machine_precision,
         )
 
         new_expr, new_defs = cls._replace_const_definitions_in_expression(
-            expression, definitions, machine_precision
+            expression, validated_defs, machine_precision
         )
         values["expression"] = new_expr
         values["definitions"] = new_defs
@@ -104,16 +148,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         pass
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         pass
 
     @classmethod
     def _replace_const_definitions_in_expression(
         cls,
         expression: str,
-        definitions: Dict[str, ValidDefinitions],
+        definitions: dict[str, ValidDefinitions],
         machine_precision: int,
-    ) -> Tuple[str, Dict[str, RegisterArithmeticInfo]]:
+    ) -> tuple[str, dict[str, RegisterArithmeticInfo]]:
         new_definitions = dict()
         for var_name, value in definitions.items():
             if isinstance(value, RegisterArithmeticInfo):
@@ -138,5 +182,5 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         return re.sub(r"\b" + var + r"\b", str(value), expression)
 
 
-def _extract_literals(expression: str) -> Set[str]:
+def _extract_literals(expression: str) -> set[str]:
     return set(re.findall(SUPPORTED_VAR_NAMES_REG, expression)) - SUPPORTED_FUNC_NAMES

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -1,9 +1,11 @@
 import ast
 from _ast import AST
-from typing import Collection, List, Optional, Set, Tuple, Type, Union, cast
+from collections.abc import Collection
+from typing import Optional, Union, cast
 
 import networkx as nx
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_EXPRESSION_TYPE,
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -16,10 +18,10 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
     AstNodeRewrite,
 )
 
-from classiq.exceptions import ClassiqArithmeticError
-
-_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple result"
-_TRIVIAL_ARITHMETIC_ERROR_MESSAGE: str = "Expression must be nontrivial"
+_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple results"
+_UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
+    "Quantum expressions that evaluate to a classical value are not supported"
+)
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]
 
@@ -27,13 +29,17 @@ Node = Union[str, float, int]
 class ExpressionVisitor(ExpressionValidator):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
     ) -> None:
         super().__init__(supported_nodes, expression_type, supported_functions)
         self.graph = nx.DiGraph()
 
+    @classmethod
+    def rewrite_ast(cls, expression_ast: AST) -> AST:
+        return AstNodeRewrite().visit(expression_ast)
+
     def visit_Compare(self, node: ast.Compare) -> None:
         self.validate_Compare(node)
         self.update_graph(node, node.left, node.comparators[0])
@@ -85,8 +91,8 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[Tuple[Node, str]]
-    ) -> List[Tuple[Node, str]]:
+        in_edges: Collection[tuple[Node, str]]
+    ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,
             key=lambda edge_tuple: isinstance(edge_tuple[0], str),  # vars before consts
@@ -122,16 +128,16 @@ class InDegreeLimiter:
         if num_results > 1:
             raise ClassiqArithmeticError(_MULTIPLE_RESULTS_ERROR_MESSAGE)
         elif num_results == 0:
-            raise ClassiqArithmeticError(_TRIVIAL_ARITHMETIC_ERROR_MESSAGE)
+            raise ClassiqArithmeticError(_UNEXPECTED_ARITHMETIC_ERROR_MESSAGE)
         return graph
 
 
 def parse_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
 ) -> nx.DiGraph:
     supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,24 +1,23 @@
 import ast
-import builtins
+import re
 from _ast import AST
-from typing import Any, Optional, Set, Tuple, Type, Union
+from typing import Any, Optional, Union
 
-from typing_extensions import get_args
+from sympy import Expr
+from typing_extensions import TypeAlias, get_args
 
+from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
 from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 
-from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
-
-DEFAULT_SUPPORTED_FUNC_NAMES: Set[str] = {"CLShift", "CRShift", "min", "max"}
+DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"CLShift", "CRShift", "min", "max"}
 
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
+IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
 
-_REPEATED_VARIABLES_ERROR_MESSAGE: str = (
-    "Repeated variables in the beginning of an arithmetic expression are not allowed."
-)
+ValidKeyValuePairs: TypeAlias = dict[str, set[str]]
 
 SupportedNodesTypes = Union[
     ast.Expression,
@@ -56,49 +55,75 @@ SupportedNodesTypes = Union[
 DEFAULT_SUPPORTED_NODE_TYPES = get_args(SupportedNodesTypes)
 
 
+def is_constant(expr: Union[str, Expr]) -> bool:
+    try:
+        float(expr)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
 class ExpressionValidator(ast.NodeVisitor):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
-        supported_attr_values: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
         mode: str = "eval",
     ) -> None:
         super().__init__()
         self.supported_nodes = supported_nodes
         self._expression_type = expression_type
         self._supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
-        self._supported_attr_values = supported_attr_values or set()
         self._mode = mode
         self._ast_obj: Optional[ast.AST] = None
 
     def validate(self, expression: str) -> None:
         try:
-            ast_expr = ast.parse(expression, filename="", mode=self._mode)
+            adjusted_expression = self._get_adjusted_expression(expression)
+            ast_expr = ast.parse(adjusted_expression, filename="", mode=self._mode)
         except SyntaxError as e:
             raise ClassiqValueError(f"Failed to parse expression {expression!r}") from e
         try:
-            self._ast_obj = AstNodeRewrite().visit(ast_expr)
+            self._ast_obj = self.rewrite_ast(ast_expr)
             self.visit(self._ast_obj)
         except RecursionError as e:
             raise ClassiqValueError(
                 f"Failed to parse expression since it is too long: {expression}"
             ) from e
 
+    @staticmethod
+    def _get_adjusted_expression(expression: str) -> str:
+        # This works around the simplification of the trivial expressions such as a + 0, 1 * a, etc.
+        if IDENITIFIER_REGEX.fullmatch(expression) or is_constant(expression):
+            return f"0 + {expression}"
+        return expression
+
     @property
     def ast_obj(self) -> ast.AST:
         if not self._ast_obj:
             raise ClassiqArithmeticError("Must call `validate` before getting ast_obj")
         return self._ast_obj
 
-    @staticmethod
-    def _check_repeated_variables(variables: Tuple[Any, Any]) -> None:
+    def _check_repeated_variables(
+        self, variables: tuple[Any, Any], expr: ast.AST, error_suffix: str
+    ) -> None:
+        if (
+            isinstance(expr, ast.BinOp)
+            and isinstance(expr.op, ast.Pow)
+            and ast.Pow not in self.supported_nodes
+        ):
+            raise ClassiqValueError(
+                "Raising to a power (<var> ** <exp>) and multiplying a variable by "
+                "itself (<var> * <var>) are not supported"
+            )
         if (
             all(isinstance(var, ast.Name) for var in variables)
             and variables[0].id == variables[1].id
         ):
-            raise ClassiqValueError(_REPEATED_VARIABLES_ERROR_MESSAGE)
+            raise ClassiqValueError(
+                f"Expression {ast.unparse(expr)!r} is not supported ({error_suffix})"
+            )
 
     @staticmethod
     def _check_multiple_comparators(node: ast.Compare) -> None:
@@ -120,7 +145,11 @@ class ExpressionValidator(ast.NodeVisitor):
         )
 
     def validate_Compare(self, node: ast.Compare) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.comparators[0]))
+        self._check_repeated_variables(
+            (node.left, node.comparators[0]),
+            node,
+            "both sides of the comparison are identical",
+        )
         self._check_multiple_comparators(node)
 
     def visit_Compare(self, node: ast.Compare) -> None:
@@ -128,7 +157,9 @@ class ExpressionValidator(ast.NodeVisitor):
         self.generic_visit(node)
 
     def validate_BinOp(self, node: ast.BinOp) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.right))
+        self._check_repeated_variables(
+            (node.left, node.right), node, "both sides of the operation are identical"
+        )
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         self.validate_BinOp(node)
@@ -136,7 +167,11 @@ class ExpressionValidator(ast.NodeVisitor):
 
     def validate_Call(self, node: ast.Call) -> None:  # noqa: N802
         if len(node.args) >= 2:
-            self._check_repeated_variables((node.args[0], node.args[1]))
+            self._check_repeated_variables(
+                (node.args[0], node.args[1]),
+                node,
+                "the first two call arguments are identical",
+            )
         node_id = AstNodeRewrite().extract_node_id(node)
         if node_id not in self._supported_functions:
             raise ClassiqValueError(f"{node_id} not in supported functions")
@@ -160,36 +195,20 @@ class ExpressionValidator(ast.NodeVisitor):
         self.validate_Constant(node)
         self.generic_visit(node)
 
-    def validate_Attribute(self, node: ast.Attribute) -> None:  # noqa: N802
-        if not (
-            isinstance(node.value, ast.Name)
-            and node.value.id in self._supported_attr_values
-        ):
-            raise ClassiqValueError(
-                f"Attribute is not supported for value {node.value}"
-            )
-
     def visit_Attribute(self, node: ast.Attribute) -> None:
-        self.validate_Attribute(node)
         self.generic_visit(node)
 
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
-        if self._mode == "exec":
-            if hasattr(builtins, node.name):
-                raise ClassiqValueError(
-                    f"Defining a function named {node.name} is forbidden"
-                )
-            self._supported_functions.add(node.name)
-        self.generic_visit(node)
+    @classmethod
+    def rewrite_ast(cls, expression_ast: AST) -> AST:
+        return expression_ast
 
 
 def validate_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
-    supported_attr_values: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
     mode: str = "eval",
 ) -> ast.AST:
     supported_functions = supported_functions or set(SYMPY_SUPPORTED_EXPRESSIONS).union(
@@ -199,7 +218,6 @@ def validate_expression(
         supported_nodes,
         expression_type,
         supported_functions,
-        supported_attr_values,
         mode,
     )
     validator.validate(expression)

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,20 +1,25 @@
-from __future__ import annotations
-
 import abc
-from typing import ClassVar, Iterable, Optional, Tuple
+from collections.abc import Iterable
+from typing import ClassVar, Final, Optional
 
 import pydantic
 
-from classiq.interface.generator.arith import argument_utils, number_utils
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
-DEFAULT_GARBAGE_OUT_NAME: str = "extra_qubits"
+IMPLICIT_OUTPUTS: Final[str] = "implicit_outputs"
+DEFAULT_GARBAGE_OUT_NAME: Final[str] = "extra_qubits"
+MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
+    "Modulo with fraction places not supported"
+)
 
 
 class ArithmeticOperationParams(FunctionParams):
-    output_size: Optional[pydantic.PositiveInt]
-    machine_precision: pydantic.PositiveInt = number_utils.MAX_FRACTION_PLACES
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+    machine_precision: pydantic.PositiveInt = DEFAULT_MACHINE_PRECISION
     output_name: ClassVar[str]
     garbage_output_name: ClassVar[str] = DEFAULT_GARBAGE_OUT_NAME
     _result_register: Optional[RegisterArithmeticInfo] = pydantic.PrivateAttr(
@@ -40,17 +45,15 @@ class ArithmeticOperationParams(FunctionParams):
         return self.output_size is None
 
     def _legal_bounds(
-        self, suggested_bounds: Tuple[float, float]
-    ) -> Optional[Tuple[float, float]]:
-        if self._include_sign or min(suggested_bounds) >= 0:
+        self, suggested_bounds: tuple[float, float], max_bounds: tuple[float, float]
+    ) -> Optional[tuple[float, float]]:
+        if self.output_size is None or (
+            suggested_bounds[0] >= max_bounds[0]
+            and suggested_bounds[1] <= max_bounds[1]
+        ):
             return suggested_bounds
         return None
 
-    def _compute_fraction_places(self, argument: argument_utils.RegisterOrConst) -> int:
-        return argument_utils.fraction_places(
-            argument, machine_precision=self.machine_precision
-        )
-
     @abc.abstractmethod
-    def get_params_inplace_options(self) -> Iterable[ArithmeticOperationParams]:
+    def get_params_inplace_options(self) -> Iterable["ArithmeticOperationParams"]:
         pass

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -1,5 +1,6 @@
-from typing import Callable, Dict, FrozenSet, List, Optional
+from typing import Callable, Optional
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith.argument_utils import (
     RegisterOrConst as RegisterOrFloat,
 )
@@ -35,12 +36,10 @@ from classiq.interface.generator.arith.logical_ops import LogicalAnd, LogicalOr
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation
 
-from classiq.exceptions import ClassiqArithmeticError
-
 ParamsGetter = Callable[..., ArithmeticOperationParams]  # Argument vary
 
 _TARGET_ERROR_MESSAGE: str = "Target unavailable for the requested operation"
-_OPERATIONS_ALLOWING_TARGET: FrozenSet = frozenset(
+_OPERATIONS_ALLOWING_TARGET: frozenset = frozenset(
     {"And", "Or", "Eq", "NotEq", "Lt", "Gt", "LtE", "GtE"}
 )
 
@@ -56,7 +55,7 @@ def operation_allows_target(operation: str) -> bool:
 def get_params(
     *,
     node_id: str,
-    args: List[RegisterOrFloat],
+    args: list[RegisterOrFloat],
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
@@ -331,7 +330,7 @@ def less_equal_params_getter(
 
 
 def logical_and_params_getter(
-    *arg: List[RegisterOrFloat],
+    *arg: list[RegisterOrFloat],
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
@@ -341,7 +340,7 @@ def logical_and_params_getter(
 
 
 def logical_or_params_getter(
-    *arg: List[RegisterOrFloat],
+    *arg: list[RegisterOrFloat],
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
@@ -435,7 +434,7 @@ def modulo_params_getter(
     )
 
 
-params_getter_map: Dict[str, ParamsGetter] = dict(
+params_getter_map: dict[str, ParamsGetter] = dict(
     BitOr=or_params_getter,
     BitAnd=and_params_getter,
     BitXor=xor_params_getter,

classiq/interface/generator/arith/arithmetic_result_builder.py

@@ -1,15 +1,14 @@
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Optional
 
 import networkx as nx
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import arithmetic_param_getters, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.ast_node_rewrite import OUTPUT_SIZE
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
-from classiq.exceptions import ClassiqArithmeticError
-
-ArithmeticDefinitions = Dict[str, RegisterOrConst]
+ArithmeticDefinitions = dict[str, RegisterOrConst]
 
 
 class ArithmeticResultBuilder:
@@ -20,7 +19,7 @@ class ArithmeticResultBuilder:
         definitions: ArithmeticDefinitions,
         machine_precision: int,
     ) -> None:
-        self.result = self._fill_operation_results(
+        self.result, self.garbage = self._fill_operation_results(
             graph=graph,
             result_definitions=definitions,
             machine_precision=machine_precision,
@@ -44,10 +43,10 @@ class ArithmeticResultBuilder:
     def _compute_inputs_data(
         cls,
         *,
-        inputs_node_set: Set[Any],
+        inputs_node_set: set[Any],
         result_definitions: ArithmeticDefinitions,
         machine_precision: int,
-    ) -> Dict[str, RegisterOrConst]:
+    ) -> dict[str, RegisterOrConst]:
         return {
             cls._convert_int_to_float_str(node): cls.convert_result_definition(
                 node, result_definitions.get(node), machine_precision
@@ -62,11 +61,11 @@ class ArithmeticResultBuilder:
         graph: nx.DiGraph,
         result_definitions: ArithmeticDefinitions,
         machine_precision: int,
-    ) -> RegisterArithmeticInfo:
-        inputs_node_set: Set[str] = {
+    ) -> tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+        inputs_node_set: set[str] = {
             vertex for vertex, deg in graph.in_degree if deg == 0
         }
-        node_results: Dict[str, RegisterOrConst] = cls._compute_inputs_data(
+        node_results: dict[str, RegisterOrConst] = cls._compute_inputs_data(
             inputs_node_set=inputs_node_set,
             result_definitions=result_definitions,
             machine_precision=machine_precision,
@@ -80,29 +79,34 @@ class ArithmeticResultBuilder:
                 for predecessor_node in graph.predecessors(node)
             ]
             if graph.out_degree(node) == 0:
-                return cls._get_node_result(
+                return cls._get_node_result_and_garbage(
                     graph, args, node, machine_precision=machine_precision
                 )
-            node_results[node] = cls._get_node_result(
+            node_results[node], _ = cls._get_node_result_and_garbage(
                 graph, args, node, machine_precision=machine_precision
             )
         raise ClassiqArithmeticError("Expression has no result")
 
     @classmethod
-    def _get_node_result(
+    def _get_node_result_and_garbage(
         cls,
         graph: nx.DiGraph,
-        args: List[RegisterOrConst],
+        args: list[RegisterOrConst],
         node: str,
         *,
         machine_precision: int,
-    ) -> RegisterArithmeticInfo:
-        return arithmetic_param_getters.get_params(
+    ) -> tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+        node_params = arithmetic_param_getters.get_params(
             node_id=node,
             args=args,
             output_size=graph.nodes[node].get(OUTPUT_SIZE, None),
             machine_precision=machine_precision,
-        ).result_register
+        )
+
+        return (
+            node_params.outputs[node_params.output_name],
+            node_params.outputs.get(node_params.garbage_output_name),
+        )
 
     @staticmethod
     def _convert_int_to_float_str(node: Any) -> str: