classiq 0.93.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

classiq/interface/executor/user_budget.py

@@ -1,5 +1,4 @@
 import datetime
-from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -11,11 +10,11 @@ from classiq.interface.helpers.versioned_model import VersionedModel
 class UserBudget(VersionedModel):
     provider: str
     currency_code: str
-    organization: Optional[str] = Field(default=None)
+    organization: str | None = Field(default=None)
     available_budget: float
     used_budget: float
     last_allocation_date: datetime.datetime
-    budget_limit: Optional[float] = Field(default=None)
+    budget_limit: float | None = Field(default=None)
 
     model_config = ConfigDict(extra="ignore")
 

classiq/interface/executor/vqe_result.py

@@ -1,7 +1,6 @@
 import base64
 import io
 from datetime import datetime
-from typing import Optional
 
 import pydantic
 from PIL import Image
@@ -18,8 +17,8 @@ Solution = tuple[int, ...]
 class SolverResult(BaseModel):
     energy: float
     # TODO: add time units (like seconds)
-    time: Optional[float] = None
-    solution: Optional[Solution] = None
+    time: float | None = None
+    solution: Solution | None = None
 
 
 class SolutionData(BaseModel):
@@ -37,7 +36,7 @@ class VQEIntermediateData(BaseModel):
     parameters: list[float] = pydantic.Field(
         description="The optimizer parameters for the variational form"
     )
-    mean_all_solutions: Optional[float] = pydantic.Field(
+    mean_all_solutions: float | None = pydantic.Field(
         default=None, description="The mean score of all solutions in this iteration"
     )
     solutions: list[SolutionData] = pydantic.Field(
@@ -51,12 +50,12 @@ class VQEIntermediateData(BaseModel):
 
 class VQESolverResult(SolverResult, QmodPyObject):
     eigenstate: dict[str, Complex]
-    reduced_probabilities: Optional[dict[str, float]] = None
+    reduced_probabilities: dict[str, float] | None = None
     optimized_circuit_sample_results: ExecutionDetails
     intermediate_results: list[VQEIntermediateData]
     optimal_parameters: dict[str, float]
     convergence_graph_str: str
-    num_solutions: Optional[int] = None
+    num_solutions: int | None = None
     num_shots: int
 
     def show_convergence_graph(self) -> None:

classiq/interface/generator/ansatz_library.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 from pydantic import BaseModel
 
 from classiq.interface.enum_utils import StrEnum
@@ -43,20 +41,20 @@ class EntanglingLayersArgs(CustomAnsatzArgs):
 class RandomArgs(CustomAnsatzArgs):
     gate_count: int = 100
     gate_probabilities: dict[str, float] = {"cx": 0.5, "u": 0.5}
-    random_seed: Optional[int] = None
+    random_seed: int | None = None
 
 
 class RandomTwoQubitGatesArgs(CustomAnsatzArgs):
     random_two_qubit_gate_count_factor: float = 1.0
-    random_seed: Optional[int] = None
+    random_seed: int | None = None
 
 
 class TwoLocalArgs(CustomAnsatzArgs):
-    rotation_blocks: Optional[Union[RotationBlocksType, list[RotationBlocksType]]] = (
+    rotation_blocks: RotationBlocksType | list[RotationBlocksType] | None = (
         RotationBlocksType.ry
     )
-    entanglement_blocks: Optional[
-        Union[EntanglementBlocksType, list[EntanglementBlocksType]]
-    ] = EntanglementBlocksType.cx
+    entanglement_blocks: None | (
+        EntanglementBlocksType | list[EntanglementBlocksType]
+    ) = EntanglementBlocksType.cx
     entanglement: EntanglementStructureType = EntanglementStructureType.full
     reps: int = 3

classiq/interface/generator/application_apis/__init__.py

@@ -3,9 +3,7 @@ from classiq.interface.generator.builtin_api_builder import (
 )
 
 from .arithmetic_declarations import *  # noqa: F403
-from .chemistry_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
-from .entangler_declarations import *  # noqa: F403
 from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())

classiq/interface/generator/arith/arithmetic.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Any, Final, Optional, cast
+from typing import Any, Final, cast
 
 import networkx as nx
 import pydantic
@@ -48,7 +48,7 @@ def is_bool(expr: str) -> bool:
 
 
 class Arithmetic(ArithmeticExpressionABC):
-    target: Optional[RegisterArithmeticInfo] = None
+    target: RegisterArithmeticInfo | None = None
     inputs_to_save: set[str] = pydantic.Field(default_factory=set)
 
     @pydantic.field_validator("inputs_to_save")

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -1,6 +1,5 @@
-from typing import Callable
-
-from typing_extensions import TypeAlias
+from collections.abc import Callable
+from typing import TypeAlias
 
 from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import argument_utils

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -1,12 +1,11 @@
 import abc
 import ast
 import re
-from typing import Any, Optional, Union
+from typing import Any, Optional, TypeAlias, 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
@@ -42,7 +41,7 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
     definitions: dict[str, ValidDefinitions]
-    qubit_count: Optional[pydantic.NonNegativeInt] = None
+    qubit_count: pydantic.NonNegativeInt | None = None
 
     def _get_literal_set(self) -> set[str]:
         return _extract_literals(self.expression)
@@ -85,7 +84,7 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         ):
             definition_dict = dict(definition_dict)
         definitions = definitions_adapter.validate_python(definition_dict)
-        machine_precision: Optional[int] = values.get(
+        machine_precision: int | None = values.get(
             "machine_precision", DEFAULT_MACHINE_PRECISION
         )
         if (
@@ -173,7 +172,7 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
 
     @staticmethod
     def _replace_numeric_value_in_expression(
-        expression: str, var: str, value: Union[int, float], machine_precision: int
+        expression: str, var: str, value: int | float, machine_precision: int
     ) -> str:
         if isinstance(value, float):
             value = number_utils.limit_fraction_places(

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -1,7 +1,8 @@
 import ast
+import re
 from _ast import AST
 from collections.abc import Collection
-from typing import Optional, Union, cast
+from typing import Union, cast
 
 import networkx as nx
 
@@ -23,6 +24,9 @@ _UNEXPECTED_ARITHMETIC_ERROR_MESSAGE: str = (
     "Quantum expressions that evaluate to a classical value are not supported"
 )
 _ALLOWED_MULTI_ARGUMENT_FUNCTIONS = ("min", "max")
+_ALLOWED_MULTI_ARGUMENT_PATTEN = re.compile(
+    rf"(({')|('.join(_ALLOWED_MULTI_ARGUMENT_FUNCTIONS)}))_[0-9]+"
+)
 Node = Union[str, float, int]
 
 
@@ -31,7 +35,7 @@ class ExpressionVisitor(ExpressionValidator):
         self,
         supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[set[str]] = None,
+        supported_functions: set[str] | None = None,
     ) -> None:
         super().__init__(supported_nodes, expression_type, supported_functions)
         self.graph = nx.DiGraph()
@@ -101,7 +105,10 @@ class InDegreeLimiter:
 
     @staticmethod
     def _condition(graph: nx.DiGraph, node: str) -> bool:
-        return graph.in_degree[node] > 2 and node in _ALLOWED_MULTI_ARGUMENT_FUNCTIONS
+        return (
+            graph.in_degree[node] > 2
+            and _ALLOWED_MULTI_ARGUMENT_PATTEN.fullmatch(node) is not None
+        )
 
     @classmethod
     def _node_conversion(cls, graph: nx.DiGraph, node: str) -> nx.DiGraph:
@@ -137,7 +144,7 @@ def parse_expression(
     *,
     supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[set[str]] = None,
+    supported_functions: set[str] | None = None,
 ) -> nx.DiGraph:
     supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,18 +1,16 @@
 import ast
 import re
 from _ast import AST
-from typing import Any, Optional, Union
+from typing import Any, TypeAlias, Union, 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,
 )
 
-DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"CLShift", "CRShift", "min", "max"}
+DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"min", "max"}
 
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
 IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
@@ -55,7 +53,7 @@ SupportedNodesTypes = Union[
 DEFAULT_SUPPORTED_NODE_TYPES = get_args(SupportedNodesTypes)
 
 
-def is_constant(expr: Union[str, Expr]) -> bool:
+def is_constant(expr: str | Expr) -> bool:
     try:
         float(expr)
         return True
@@ -72,7 +70,7 @@ class ExpressionValidator(ast.NodeVisitor):
         self,
         supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[set[str]] = None,
+        supported_functions: set[str] | None = None,
         mode: str = "eval",
     ) -> None:
         super().__init__()
@@ -80,7 +78,7 @@ class ExpressionValidator(ast.NodeVisitor):
         self._expression_type = expression_type
         self._supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
         self._mode = mode
-        self._ast_obj: Optional[ast.AST] = None
+        self._ast_obj: ast.AST | None = None
 
     def validate(self, expression: str) -> None:
         try:
@@ -171,14 +169,13 @@ class ExpressionValidator(ast.NodeVisitor):
                 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")
-
-        if node_id in ("CLShift", "CRShift") and (
-            len(node.args) != 2 or not isinstance(node.args[1], ast.Constant)
+        if (
+            not isinstance(node.func, ast.Name)
+            or node.func.id not in self._supported_functions
         ):
-            raise ClassiqValueError("Cyclic Shift expects 2 arguments (exp, int)")
+            raise ClassiqValueError(
+                f"{ast.unparse(node.func)} not in supported functions"
+            )
 
     def visit_Call(self, node: ast.Call) -> None:
         self.validate_Call(node)
@@ -207,7 +204,7 @@ def validate_expression(
     *,
     supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[set[str]] = None,
+    supported_functions: set[str] | None = None,
     mode: str = "eval",
 ) -> ast.AST:
     supported_functions = supported_functions or set(SYMPY_SUPPORTED_EXPRESSIONS).union(

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,6 +1,6 @@
 import abc
 from collections.abc import Iterable
-from typing import ClassVar, Final, Optional
+from typing import ClassVar, Final
 
 import pydantic
 
@@ -18,13 +18,11 @@ MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
 
 
 class ArithmeticOperationParams(FunctionParams):
-    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+    output_size: pydantic.PositiveInt | None = 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(
-        default=None
-    )
+    _result_register: RegisterArithmeticInfo | None = pydantic.PrivateAttr(default=None)
 
     @abc.abstractmethod
     def _get_result_register(self) -> RegisterArithmeticInfo:
@@ -46,7 +44,7 @@ class ArithmeticOperationParams(FunctionParams):
 
     def _legal_bounds(
         self, suggested_bounds: tuple[float, float], max_bounds: tuple[float, float]
-    ) -> Optional[tuple[float, float]]:
+    ) -> tuple[float, float] | None:
         if self.output_size is None or (
             suggested_bounds[0] >= max_bounds[0]
             and suggested_bounds[1] <= max_bounds[1]