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

classiq/evaluators/qmod_expression_visitors/sympy_wrappers.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from sympy import Function, Integer
 from sympy.logic.boolalg import BooleanFunction
@@ -6,7 +6,7 @@ from sympy.logic.boolalg import BooleanFunction
 
 class BitwiseAnd(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a & b
 
@@ -15,7 +15,7 @@ class BitwiseAnd(Function):
 
 class BitwiseXor(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a ^ b
 
@@ -24,7 +24,7 @@ class BitwiseXor(Function):
 
 class LogicalXor(BooleanFunction):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[bool]:
+    def eval(cls, a: Any, b: Any) -> bool | None:
         if isinstance(a, bool) and isinstance(b, bool):
             return a ^ b
 
@@ -33,7 +33,7 @@ class LogicalXor(BooleanFunction):
 
 class BitwiseOr(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a | b
 
@@ -42,7 +42,7 @@ class BitwiseOr(Function):
 
 class BitwiseNot(Function):
     @classmethod
-    def eval(cls, a: Any) -> Optional[int]:
+    def eval(cls, a: Any) -> int | None:
         if isinstance(a, Integer):
             return ~a
 
@@ -51,7 +51,7 @@ class BitwiseNot(Function):
 
 class RShift(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a >> b
 
@@ -60,7 +60,7 @@ class RShift(Function):
 
 class LShift(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a << b
 

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -160,28 +160,28 @@ def _infer_binary_op_type(
         if right_value is None or treat_qnum_as_float:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_modulo(
-            left_attrs, right_value, machine_precision
+            left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.Pow):
         if right_value is None or treat_qnum_as_float:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_power(
-            left_attrs, right_value, machine_precision
+            left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.LShift):
         if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_lshift(
-            left_attrs, right_value, machine_precision
+            left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.RShift):
         if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_rshift(
-            left_attrs, right_value, machine_precision
+            left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.BitAnd):

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -1,11 +1,13 @@
 import ast
-from typing import Callable, Union, cast
+from collections.abc import Callable
+from typing import cast
 
 import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
+    ClassiqValueError,
 )
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
@@ -19,7 +21,6 @@ from classiq.interface.generator.functions.classical_type import (
     Real,
 )
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
@@ -39,7 +40,7 @@ INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
 
 
 def _check_classical_array_arg_type(
-    param_type: Union[ClassicalArray, ClassicalTuple], arg_type: ClassicalType
+    param_type: ClassicalArray | ClassicalTuple, arg_type: ClassicalType
 ) -> bool:
     if not isinstance(arg_type, (ClassicalArray, ClassicalTuple)):
         return False
@@ -63,7 +64,7 @@ def _check_classical_array_arg_type(
         )
     return all(
         check_classical_arg_type(param_element_type, arg_element_type)
-        for param_element_type, arg_element_type in zip_strict(
+        for param_element_type, arg_element_type in zip(
             param_type.element_types, arg_type.element_types, strict=True
         )
     )
@@ -208,6 +209,15 @@ def try_eval_sympy_function(
 
 def try_eval_builtin_function(
     expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    try:
+        return _try_eval_builtin_function(expr_val, node, func_name)
+    except ValueError as e:
+        raise ClassiqValueError(str(e)) from e
+
+
+def _try_eval_builtin_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
 ) -> bool:
     args_are_int = all(isinstance(expr_val.get_type(arg), Integer) for arg in node.args)
     args_are_real = all(

classiq/evaluators/qmod_node_evaluators/list_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Optional, cast
+from typing import cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -57,7 +57,7 @@ def list_allowed(classical_types: list[ClassicalType]) -> bool:
     if len(classical_types) < 2:
         return True
 
-    element_without_empty_tuple: Optional[ClassicalType] = None
+    element_without_empty_tuple: ClassicalType | None = None
     for classical_type in classical_types:
         if not _has_empty_tuple(classical_type):
             element_without_empty_tuple = classical_type

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import sympy
 
@@ -22,7 +22,7 @@ def get_numeric_attrs(
     qmod_type: QmodType,
     machine_precision: int,
     treat_qnum_as_float: bool,
-) -> Optional[NumericAttributes]:
+) -> NumericAttributes | None:
     if isinstance(qmod_type, Bool):
         return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
     if is_classical_type(qmod_type):
@@ -45,7 +45,7 @@ def get_classical_value_for_arithmetic(
     node: ast.AST,
     qmod_type: QmodType,
     treat_qnum_as_float: bool,
-) -> Optional[float]:
+) -> float | None:
     if not is_classical_type(qmod_type):
         return None
     if not expr_val.has_value(node):

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Optional, cast
+from typing import cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -53,12 +53,12 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
                 f"Slice indices must be integers, not {index_type.raw_qmod_type_name}"
             )
 
-    start_val: Optional[int] = None
+    start_val: int | None = None
     if expr_val.has_value(start):
         start_val = cast(int, expr_val.get_value(start))
         if start_val < 0:
             raise ClassiqExpansionError("Slice indices must be positive integers")
-    stop_val: Optional[int] = None
+    stop_val: int | None = None
     if expr_val.has_value(stop):
         stop_val = cast(int, expr_val.get_value(stop))
         if start_val is not None and stop_val < start_val:
@@ -74,7 +74,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
             or (stop_val is not None and stop_val > subject_type.length_value)
         ):
             raise ClassiqExpansionError("Array index out of range")
-        length_expr: Optional[Expression] = None
+        length_expr: Expression | None = None
         if start_val is not None and stop_val is not None:
             length_expr = Expression(expr=str(stop_val - start_val))
         slice_type = ClassicalArray(
@@ -139,7 +139,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
             f"{index_type.raw_qmod_type_name}"
         )
 
-    sub_val: Optional[int] = None
+    sub_val: int | None = None
     if expr_val.has_value(subscript):
         sub_val = cast(int, expr_val.get_value(subscript))
         if sub_val < 0:
@@ -195,10 +195,10 @@ def eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> No
 
 
 def validate_quantum_subscript_index_properties(
-    index_size: Optional[int],
-    index_sign: Optional[bool],
-    index_fraction_digits: Optional[int],
-    array_len: Optional[int],
+    index_size: int | None,
+    index_sign: bool | None,
+    index_fraction_digits: int | None,
+    array_len: int | None,
 ) -> None:
     if index_sign or (index_fraction_digits is not None and index_fraction_digits > 0):
         raise ClassiqValueError("Quantum index must be an unsigned integer")

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, cast
+from typing import Union, cast
 
 import sympy
 
@@ -42,7 +42,7 @@ def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
 
 def get_numeric_properties(
     qmod_type: QuantumScalar,
-) -> tuple[Optional[int], Optional[bool], Optional[int]]:
+) -> tuple[int | None, bool | None, int | None]:
     if isinstance(qmod_type, QuantumBit):
         return 1, False, 0
     if not isinstance(qmod_type, QuantumNumeric):
@@ -66,7 +66,7 @@ def get_numeric_properties(
 
 
 def element_types(
-    classical_type: Union[ClassicalArray, ClassicalTuple],
+    classical_type: ClassicalArray | ClassicalTuple,
 ) -> list[ClassicalType]:
     if isinstance(classical_type, ClassicalArray):
         return [classical_type.element_type]
@@ -74,8 +74,8 @@ def element_types(
 
 
 def array_len(
-    classical_type: Union[ClassicalArray, ClassicalTuple],
-) -> Optional[int]:
+    classical_type: ClassicalArray | ClassicalTuple,
+) -> int | None:
     if isinstance(classical_type, ClassicalTuple):
         return len(classical_type.element_types)
     if classical_type.has_constant_length:
@@ -95,7 +95,7 @@ def is_classical_integer(qmod_type: QmodType) -> bool:
     )
 
 
-def get_sympy_val(val: sympy.Basic) -> Union[bool, int, float, complex]:
+def get_sympy_val(val: sympy.Basic) -> bool | int | float | complex:
     if hasattr(val, "is_Boolean") and val.is_Boolean:
         return bool(val)
     if (hasattr(val, "is_integer") and val.is_integer) or (

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -1,5 +1,5 @@
 from enum import IntEnum
-from typing import Any, Optional, Union
+from typing import Any
 
 import sympy
 
@@ -18,14 +18,13 @@ from classiq.interface.generator.functions.classical_type import (
 )
 from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.backward_compatibility import zip_strict
 
 from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
 
 
 def _copy_generative_flag(
-    from_type: ClassicalType, to_type: Optional[ClassicalType]
-) -> Optional[ClassicalType]:
+    from_type: ClassicalType, to_type: ClassicalType | None
+) -> ClassicalType | None:
     if to_type is None:
         return None
     if from_type.is_generative:
@@ -65,11 +64,11 @@ def infer_classical_type(value: Any) -> ClassicalType:
 
 
 def _inject_classical_array_attributes(
-    from_type: ClassicalType, to_type: Union[ClassicalArray, ClassicalTuple]
-) -> Optional[ClassicalType]:
+    from_type: ClassicalType, to_type: ClassicalArray | ClassicalTuple
+) -> ClassicalType | None:
     if isinstance(to_type, ClassicalArray):
         if isinstance(from_type, ClassicalArray):
-            length: Optional[Expression]
+            length: Expression | None
             if from_type.has_constant_length:
                 if (
                     to_type.has_constant_length
@@ -116,7 +115,7 @@ def _inject_classical_array_attributes(
             return None
         element_types = [
             inject_classical_type_attributes(from_element_type, to_element_type)
-            for from_element_type, to_element_type in zip_strict(
+            for from_element_type, to_element_type in zip(
                 from_type.element_types, to_type.element_types, strict=True
             )
         ]
@@ -128,7 +127,7 @@ def _inject_classical_array_attributes(
 
 def _inject_classical_type_name_attributes(
     from_type: ClassicalType, to_type: TypeName
-) -> Optional[ClassicalType]:
+) -> ClassicalType | None:
     if to_type.is_enum:
         if isinstance(from_type, Integer) or (
             isinstance(from_type, TypeName) and from_type.name == to_type.name
@@ -157,7 +156,7 @@ def _inject_classical_type_name_attributes(
 
 def inject_classical_type_attributes(
     from_type: ClassicalType, to_type: ClassicalType
-) -> Optional[ClassicalType]:
+) -> ClassicalType | None:
     if isinstance(to_type, Bool):
         if isinstance(from_type, Bool):
             return _copy_generative_flag(to_type, Bool())

classiq/evaluators/qmod_type_inference/quantum_type_inference.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -80,7 +80,7 @@ def _same_shape(quantum_type_1: QuantumType, quantum_type_2: QuantumType) -> boo
 def _inject_qnum_type_attributes(
     from_type: QuantumType, to_type: QuantumNumeric
 ) -> QuantumNumeric:
-    size: Optional[Expression]
+    size: Expression | None
     if from_type.has_size_in_bits:
         size = Expression(expr=str(from_type.size_in_bits))
     else:
@@ -126,7 +126,7 @@ def _inject_qnum_type_attributes(
 
 def _inject_qarray_type_attributes(
     from_type: QuantumType, to_type: QuantumBitvector
-) -> Optional[QuantumBitvector]:
+) -> QuantumBitvector | None:
     if _same_shape(from_type, to_type):
         if TYPE_CHECKING:
             assert isinstance(from_type, QuantumBitvector)
@@ -182,7 +182,7 @@ def _inject_qarray_type_attributes(
 
 def _inject_qstruct_type_attributes(
     from_type: QuantumType, to_type: TypeName
-) -> Optional[TypeName]:
+) -> TypeName | None:
     if isinstance(from_type, TypeName) and from_type.name == to_type.name:
         fields = {
             field_name: inject_quantum_type_attributes(
@@ -241,7 +241,7 @@ def _inject_qstruct_type_attributes(
 
 def inject_quantum_type_attributes(
     from_type: QuantumType, to_type: QuantumType
-) -> Optional[QuantumType]:
+) -> QuantumType | None:
     for qmod_type in (from_type, to_type):
         if isinstance(qmod_type, TypeName) and not qmod_type.has_fields:
             raise ClassiqInternalExpansionError

classiq/execution/__init__.py

@@ -8,7 +8,6 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
-from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
 from .qnn import execute_qnn
 from .user_budgets import (
@@ -33,8 +32,6 @@ __all__ = (
         "get_execution_jobs_async",
         "ExecutionSession",
         "execute_qnn",
-        "generate_iqcc_token",
-        "generate_iqcc_token_async",
         "get_budget",
         "get_budget_async",
         "set_budget_limit",

classiq/execution/execution_session.py

@@ -1,8 +1,9 @@
 import inspect
 import random
 import warnings
+from collections.abc import Callable
 from types import TracebackType
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
 from classiq.interface.exceptions import (
@@ -104,7 +105,7 @@ class ExecutionSession:
     def __init__(
         self,
         quantum_program: QuantumProgram,
-        execution_preferences: Optional[ExecutionPreferences] = None,
+        execution_preferences: ExecutionPreferences | None = None,
     ):
         self.program: QuantumProgram = quantum_program
         self.update_execution_preferences(execution_preferences)
@@ -124,9 +125,9 @@ class ExecutionSession:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.close()
 
@@ -156,7 +157,7 @@ class ExecutionSession:
         return ExecutionJob(details=result)
 
     def update_execution_preferences(
-        self, execution_preferences: Optional[ExecutionPreferences]
+        self, execution_preferences: ExecutionPreferences | None
     ) -> None:
         """
         Update the execution preferences for the session.
@@ -170,7 +171,7 @@ class ExecutionSession:
         if execution_preferences is not None:
             self.program.model.execution_preferences = execution_preferences
 
-    def sample(self, parameters: Optional[ExecutionParams] = None) -> ExecutionDetails:
+    def sample(self, parameters: ExecutionParams | None = None) -> ExecutionDetails:
         """
         Samples the quantum program with the given parameters, if any.
 
@@ -183,9 +184,7 @@ class ExecutionSession:
         job = self.submit_sample(parameters=parameters)
         return job.get_sample_result(_http_client=self._async_client)
 
-    def submit_sample(
-        self, parameters: Optional[ExecutionParams] = None
-    ) -> ExecutionJob:
+    def submit_sample(self, parameters: ExecutionParams | None = None) -> ExecutionJob:
         """
         Initiates an execution job with the `sample` primitive.
 
@@ -235,7 +234,7 @@ class ExecutionSession:
         return self._execute(execution_primitives_input)
 
     def estimate(
-        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+        self, hamiltonian: Hamiltonian, parameters: ExecutionParams | None = None
     ) -> EstimationResult:
         """
         Estimates the expectation value of the given Hamiltonian using the quantum program.
@@ -246,6 +245,9 @@ class ExecutionSession:
 
         Returns:
             EstimationResult: The result of the estimation.
+
+        See Also:
+            More information about [Hamiltonians](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians).
         """
         _hamiltonian_deprecation_warning(hamiltonian)
         job = self.submit_estimate(
@@ -256,7 +258,7 @@ class ExecutionSession:
     def submit_estimate(
         self,
         hamiltonian: Hamiltonian,
-        parameters: Optional[ExecutionParams] = None,
+        parameters: ExecutionParams | None = None,
         *,
         _check_deprecation: bool = True,
     ) -> ExecutionJob:
@@ -336,14 +338,15 @@ class ExecutionSession:
 
     def minimize(
         self,
-        cost_function: Union[Hamiltonian, QmodExpressionCreator],
+        cost_function: Hamiltonian | QmodExpressionCreator,
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
-        tolerance: Optional[float] = None,
+        tolerance: float | None = None,
     ) -> list[tuple[float, ExecutionParams]]:
         """
         Minimizes the given cost function using the quantum program.
+
         Args:
             cost_function: The cost function to minimize. It can be one of the following:
                 - A quantum cost function defined by a Hamiltonian.
@@ -357,9 +360,13 @@ class ExecutionSession:
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
             tolerance: The tolerance for the minimization.
+
         Returns:
-            A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
-            `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
+             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration. `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
+
+        See Also:
+            The [Classiq Tutorial](https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/) has examples on using this method in variational quantum algorithms.
+            More information about [Hamiltonians](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians).
         """
         _hamiltonian_deprecation_warning(cost_function)
         job = self.submit_minimize(
@@ -378,11 +385,11 @@ class ExecutionSession:
 
     def submit_minimize(
         self,
-        cost_function: Union[Hamiltonian, QmodExpressionCreator],
+        cost_function: Hamiltonian | QmodExpressionCreator,
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
-        tolerance: Optional[float] = None,
+        tolerance: float | None = None,
         *,
         _check_deprecation: bool = True,
     ) -> ExecutionJob:
@@ -416,9 +423,9 @@ class ExecutionSession:
                 "The initial parameters must be a dictionary with a single key-value pair."
             )
 
-        _cost_function: Union[PauliOperator, Expression]
+        _cost_function: PauliOperator | Expression
         _initial_params = parse_params(initial_params)
-        minimize: Union[MinimizeQuantumCostInput, MinimizeClassicalCostInput]
+        minimize: MinimizeQuantumCostInput | MinimizeClassicalCostInput
         if callable(cost_function):
             circuit_output_types = self.program.model.circuit_output_types
             _cost_function = self._create_qmod_expression(
@@ -447,7 +454,7 @@ class ExecutionSession:
     def estimate_cost(
         self,
         cost_func: Callable[[ParsedState], float],
-        parameters: Optional[ExecutionParams] = None,
+        parameters: ExecutionParams | None = None,
         quantile: float = 1.0,
     ) -> float:
         """