classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

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,11 +18,9 @@ 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"
+_MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple results"
 _UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
-    "Unexpected arithmetic error: trivial expression. Please contact support."
+    "Quantum expressions that evaluate to a classical value are not supported"
 )
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]
@@ -29,9 +29,9 @@ 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()
@@ -91,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
@@ -135,9 +135,9 @@ class InDegreeLimiter:
 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,26 +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,
@@ -58,20 +55,26 @@ 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
 
@@ -92,7 +95,7 @@ class ExpressionValidator(ast.NodeVisitor):
     @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):
+        if IDENITIFIER_REGEX.fullmatch(expression) or is_constant(expression):
             return f"0 + {expression}"
         return expression
 
@@ -102,13 +105,25 @@ class ExpressionValidator(ast.NodeVisitor):
             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:
@@ -130,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:
@@ -138,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)
@@ -146,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")
@@ -170,26 +195,7 @@ 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
@@ -200,10 +206,9 @@ class ExpressionValidator(ast.NodeVisitor):
 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(
@@ -213,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,5 +1,6 @@
 import abc
-from typing import ClassVar, Iterable, Optional, Tuple
+from collections.abc import Iterable
+from typing import ClassVar, Final, Optional
 
 import pydantic
 
@@ -9,11 +10,15 @@ from classiq.interface.generator.arith.machine_precision import (
 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]
+    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
@@ -40,9 +45,12 @@ 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
 

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:

classiq/interface/generator/arith/ast_node_rewrite.py

@@ -1,8 +1,9 @@
 import ast
 import itertools
-from typing import Any, Iterator, Optional, Union, cast
+from collections.abc import Iterator
+from typing import Any, Optional, Union, cast
 
-from classiq.exceptions import ClassiqArithmeticError
+from classiq.interface.exceptions import ClassiqArithmeticError
 
 SEPARATOR: str = "_"
 OUTPUT_SIZE: str = "output_size"