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

classiq/interface/executor/result.py

@@ -9,13 +9,13 @@ from typing import (
     Any,
     DefaultDict,
     Optional,
+    TypeAlias,
     Union,
 )
 
-import pandas as pd
 import pydantic
 from pydantic import BaseModel
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from classiq.interface.exceptions import (
     ClassiqError,
@@ -52,6 +52,8 @@ MAGNITUDE = "magnitude"
 PHASE = "phase"
 
 if TYPE_CHECKING:
+    import pandas as pd
+
     DotAccessParsedState = Mapping[Name, Any]
 else:
     DotAccessParsedState = ParsedState
@@ -90,8 +92,8 @@ ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
-    var: Optional[float] = None
-    alpha: Optional[float] = None
+    var: float | None = None
+    alpha: float | None = None
 
 
 class GroverSimulationResults(VersionedModel):
@@ -119,7 +121,7 @@ def flip_counts_qubit_order(counts: Counts) -> Counts:
 
 def get_sampled_state(
     parsed_counts: ParsedCounts, state: ParsedState
-) -> Optional[SampledState]:
+) -> SampledState | None:
     for sampled_state in parsed_counts:
         if sampled_state.state == state:
             return sampled_state
@@ -150,7 +152,7 @@ def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCoun
 
 def prepare_parsed_state_vector(
     state_vector: StateVector, parsed_state_vector_states: ParsedStates
-) -> Optional[ParsedStateVector]:
+) -> ParsedStateVector | None:
     if not state_vector:
         return None
 
@@ -165,7 +167,11 @@ def prepare_parsed_state_vector(
     return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
 
 
-def _flatten_columns(df: pd.DataFrame, columns_to_flatten: list[str]) -> pd.DataFrame:
+def _flatten_columns(
+    df: "pd.DataFrame", columns_to_flatten: list[str]
+) -> "pd.DataFrame":
+    import pandas as pd
+
     if len(df.columns) == 0:
         return df
 
@@ -221,7 +227,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default_factory=dict,
         description="A mapping between the raw states of counts (bitstrings) to their parsed states (registers' values)",
     )
-    histogram: Optional[dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
+    histogram: dict[State, pydantic.NonNegativeFloat] | None = pydantic.Field(
         None,
         description="Histogram of probability per state (an alternative to counts)",
     )
@@ -233,15 +239,15 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None,
         description="The state vector when executed on a simulator, with LSB right qubit order",
     )
-    parsed_state_vector_states: Optional[ParsedStates] = pydantic.Field(
+    parsed_state_vector_states: ParsedStates | None = pydantic.Field(
         default=None,
         description="A mapping between the raw states of the state vector (bitstrings) to their parsed states (registers' values)",
     )
-    physical_qubits_map: Optional[OutputQubitsMap] = pydantic.Field(
+    physical_qubits_map: OutputQubitsMap | None = pydantic.Field(
         default=None,
         description="The map of all registers (also non measured) to their qubits in the circuit. Used for state_vector which represent also the non-measured qubits.",
     )
-    num_shots: Optional[pydantic.NonNegativeInt] = pydantic.Field(
+    num_shots: pydantic.NonNegativeInt | None = pydantic.Field(
         default=None, description="The total number of shots the circuit was executed"
     )
 
@@ -274,7 +280,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return get_parsed_counts(self.counts, self.parsed_states)
 
     @property
-    def parsed_state_vector(self) -> Optional[ParsedStateVector]:
+    def parsed_state_vector(self) -> ParsedStateVector | None:
         if TYPE_CHECKING:
             assert self.parsed_state_vector_states is not None
         return prepare_parsed_state_vector(
@@ -327,7 +333,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return dict(reduced_counts)
 
     def parsed_counts_of_outputs(
-        self, output_names: Union[Name, tuple[Name, ...]]
+        self, output_names: Name | tuple[Name, ...]
     ) -> ParsedCounts:
         if isinstance(output_names, Name):
             output_names = (output_names,)
@@ -361,7 +367,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         )[::-1]
         return number_utils.binary_to_float_or_int(bin_rep=register_binary_string)
 
-    def _counts_df(self) -> pd.DataFrame:
+    def _counts_df(self) -> "pd.DataFrame":
+        import pandas as pd
+
         data: dict[str, Any] = defaultdict(list)
 
         for bitstring, count in self.counts.items():
@@ -382,7 +390,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
         return pd.DataFrame(data, columns=columns)
 
-    def _state_vector_df(self) -> pd.DataFrame:
+    def _state_vector_df(self) -> "pd.DataFrame":
+        import pandas as pd
+
         data: dict[str, Any] = defaultdict(list)
 
         if not self.state_vector:
@@ -408,7 +418,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return pd.DataFrame(data, columns=columns)
 
     @functools.cached_property
-    def dataframe(self) -> pd.DataFrame:
+    def dataframe(self) -> "pd.DataFrame":
         reserved_words = frozenset(
             [BITSTRING, PROBABILITY, COUNT, AMPLITUDE, PHASE, MAGNITUDE]
         )
@@ -449,9 +459,9 @@ class MultipleExecutionDetails(VersionedModel):
 
 
 class EstimationMetadata(BaseModel, extra="allow"):
-    shots: Optional[pydantic.NonNegativeInt] = None
+    shots: pydantic.NonNegativeInt | None = None
     remapped_qubits: bool = False
-    input_qubit_map: Optional[list[PydanticNonNegIntTuple]] = None
+    input_qubit_map: list[PydanticNonNegIntTuple] | None = None
 
 
 class EstimationResult(BaseModel, QmodPyObject):

classiq/interface/executor/user_budget.py

@@ -1,21 +1,21 @@
 import datetime
-from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict, Field
 from tabulate import tabulate
 
+from classiq.interface.backend.quantum_backend_providers import PROVIDER_NAME_MAPPER
 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")
 
@@ -24,20 +24,28 @@ class UserBudgets(VersionedModel):
     budgets: list[UserBudget] = pydantic.Field(default=[])
 
     def __str__(self) -> str:
-        rows = [
-            [
-                budget.provider,
-                f"{budget.used_budget:.3f}",
-                f"{budget.available_budget:.3f}",
-                (
-                    f"{budget.budget_limit:.3f}"
-                    if budget.budget_limit is not None
-                    else "NOT SET"
-                ),
-                budget.currency_code,
-            ]
-            for budget in self.budgets
-        ]
+        reverse_mapper = {v: k for k, v in PROVIDER_NAME_MAPPER.items()}
+        rows = []
+
+        for budget in self.budgets:
+            provider_key = reverse_mapper.get(budget.provider, budget.provider)
+            rows.append(
+                [
+                    (
+                        provider_key.name
+                        if hasattr(provider_key, "name")
+                        else provider_key
+                    ),
+                    f"{budget.used_budget:.3f}",
+                    f"{budget.available_budget:.3f}",
+                    (
+                        f"{budget.budget_limit:.3f}"
+                        if budget.budget_limit is not None
+                        else "NOT SET"
+                    ),
+                    budget.currency_code,
+                ]
+            )
 
         headers = [
             "Provider",

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,6 @@ 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]