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

classiq/interface/generator/arith/argument_utils.py

@@ -6,10 +6,10 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 RegisterOrConst = Union[RegisterArithmeticInfo, float]
 
 
-def fraction_places(argument: RegisterOrConst, *, machine_precision: int) -> int:
+def fraction_places(argument: RegisterOrConst) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.fraction_places
-    return number_utils.fraction_places(argument, machine_precision=machine_precision)
+    return number_utils.fraction_places(argument)
 
 
 def integer_part_size(argument: RegisterOrConst) -> int:
@@ -18,10 +18,10 @@ def integer_part_size(argument: RegisterOrConst) -> int:
     return number_utils.integer_part_size(argument)
 
 
-def size(argument: RegisterOrConst, *, machine_precision: int) -> int:
+def size(argument: RegisterOrConst) -> int:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.size
-    return number_utils.size(argument, machine_precision=machine_precision)
+    return number_utils.size(argument)
 
 
 def is_signed(argument: RegisterOrConst) -> bool:
@@ -46,3 +46,13 @@ def bounds(argument: RegisterOrConst) -> Tuple[float, float]:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.bounds
     return argument, argument
+
+
+def limit_fraction_places(
+    argument: RegisterOrConst, *, machine_precision: int
+) -> RegisterOrConst:
+    if isinstance(argument, RegisterArithmeticInfo):
+        return argument.limit_fraction_places(machine_precision)
+    return number_utils.limit_fraction_places(
+        argument, machine_precision=machine_precision
+    )

classiq/interface/generator/arith/arithmetic.py

@@ -21,6 +21,8 @@ from classiq.interface.model.quantum_type import (
     register_info_to_quantum_type,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 ARITHMETIC_EXPRESSION_TARGET_NAME: str = "arithmetic_target"
 ARITHMETIC_EXPRESSION_RESULT_NAME: str = "expression_result"
 
@@ -47,7 +49,7 @@ class Arithmetic(ArithmeticExpressionABC):
             degree or operation_allows_target(id2op(node))
             for node, degree in graph.out_degree
         ):
-            raise ValueError("Expression does not support target assignment")
+            raise ClassiqValueError("Expression does not support target assignment")
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -2,23 +2,16 @@ from typing import Callable, Dict, List
 
 from typing_extensions import TypeAlias
 
-from classiq.interface.generator.arith.argument_utils import (
-    RegisterOrConst,
-    fraction_places,
-)
+from classiq.interface.generator.arith import argument_utils
 from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIONS_ERROR
 
 from classiq.exceptions import ClassiqArithmeticError
 
-ArgTypeValidator: TypeAlias = Callable[[List[RegisterOrConst], int], None]
+ArgTypeValidator: TypeAlias = Callable[[List[argument_utils.RegisterOrConst]], None]
 
 
-def _validate_bitwise_op_args(
-    args: List[RegisterOrConst], machine_precision: int
-) -> None:
-    if any(
-        fraction_places(arg, machine_precision=machine_precision) > 0 for arg in args
-    ):
+def _validate_bitwise_op_args(args: List[argument_utils.RegisterOrConst]) -> None:
+    if any(argument_utils.fraction_places(arg) > 0 for arg in args):
         raise ClassiqArithmeticError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
 
 
@@ -30,8 +23,14 @@ arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
 
 
 def validate_operation_arg_types(
-    operation: str, args: List[RegisterOrConst], machine_precision: int
+    operation: str,
+    arguments: List[argument_utils.RegisterOrConst],
+    machine_precision: int,
 ) -> None:
     if operation not in arg_type_validator_map:
         return
-    arg_type_validator_map[operation](args, machine_precision)
+    limited_args = [
+        argument_utils.limit_fraction_places(arg, machine_precision=machine_precision)
+        for arg in arguments
+    ]
+    arg_type_validator_map[operation](limited_args)

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -17,6 +17,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 (
@@ -36,7 +39,7 @@ 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]
     qubit_count: Optional[pydantic.NonNegativeInt] = None

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -19,7 +19,9 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
 from classiq.exceptions import ClassiqArithmeticError
 
 _MULTIPLE_RESULTS_ERROR_MESSAGE: str = "Expression cannot contain multiple result"
-_TRIVIAL_ARITHMETIC_ERROR_MESSAGE: str = "Expression must be nontrivial"
+_UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
+    "Unexpected arithmetic error: trivial expression. Please contact support."
+)
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
 Node = Union[str, float, int]
 
@@ -34,6 +36,10 @@ class ExpressionVisitor(ExpressionValidator):
         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])
@@ -122,7 +128,7 @@ 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
 
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,5 +1,6 @@
 import ast
 import builtins
+import re
 from _ast import AST
 from typing import Any, Optional, Set, Tuple, Type, Union
 
@@ -15,6 +16,7 @@ from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
 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."
@@ -75,17 +77,25 @@ class ExpressionValidator(ast.NodeVisitor):
 
     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):
+            return f"0 + {expression}"
+        return expression
+
     @property
     def ast_obj(self) -> ast.AST:
         if not self._ast_obj:
@@ -182,6 +192,10 @@ class ExpressionValidator(ast.NodeVisitor):
             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,

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,11 +1,11 @@
-from __future__ import annotations
-
 import abc
 from typing import ClassVar, Iterable, Optional, Tuple
 
 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
 
@@ -14,7 +14,7 @@ DEFAULT_GARBAGE_OUT_NAME: str = "extra_qubits"
 
 class ArithmeticOperationParams(FunctionParams):
     output_size: Optional[pydantic.PositiveInt]
-    machine_precision: pydantic.PositiveInt = number_utils.MAX_FRACTION_PLACES
+    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(
@@ -46,11 +46,6 @@ class ArithmeticOperationParams(FunctionParams):
             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/ast_node_rewrite.py

@@ -30,7 +30,7 @@ class AstNodeRewrite(ast.NodeTransformer):
         elif hasattr(node, "op"):
             return type(node.op).__name__ + next(self.count_str_gen)
         elif hasattr(node, "func"):
-            return node.func.id
+            return self.extract_node_id(node.func)
         elif hasattr(node, "value"):
             return node.value
         elif hasattr(node, "ops"):