classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -1,4 +1,4 @@
-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 (
@@ -39,7 +39,7 @@ from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation
 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"}
 )
 
@@ -55,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,
@@ -330,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,
@@ -340,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,
@@ -434,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,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Optional
 
 import networkx as nx
 
@@ -8,7 +8,7 @@ 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
 
-ArithmeticDefinitions = Dict[str, RegisterOrConst]
+ArithmeticDefinitions = dict[str, RegisterOrConst]
 
 
 class ArithmeticResultBuilder:
@@ -43,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
@@ -61,11 +61,11 @@ class ArithmeticResultBuilder:
         graph: nx.DiGraph,
         result_definitions: ArithmeticDefinitions,
         machine_precision: int,
-    ) -> Tuple[RegisterArithmeticInfo, Optional[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,
@@ -91,11 +91,11 @@ class ArithmeticResultBuilder:
     def _get_node_result_and_garbage(
         cls,
         graph: nx.DiGraph,
-        args: List[RegisterOrConst],
+        args: list[RegisterOrConst],
         node: str,
         *,
         machine_precision: int,
-    ) -> Tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+    ) -> tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
         node_params = arithmetic_param_getters.get_params(
             node_id=node,
             args=args,

classiq/interface/generator/arith/ast_node_rewrite.py

@@ -1,6 +1,7 @@
 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.interface.exceptions import ClassiqArithmeticError
 

classiq/interface/generator/arith/binary_ops.py

@@ -1,14 +1,11 @@
 import math
+from collections.abc import Iterable
 from typing import (
     Any,
     ClassVar,
-    Dict,
     Generic,
-    Iterable,
     Literal,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
@@ -65,7 +62,7 @@ class BinaryOpParams(
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _clone_repeated_arg(cls, values: Any) -> Dict[str, Any]:
+    def _clone_repeated_arg(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             left_arg = values.get("left_arg")
             right_arg = values.get("right_arg")
@@ -113,7 +110,7 @@ class InplacableBinaryOpParams(
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_inplace_arg(cls, values: Any) -> Dict[str, Any]:
+    def _validate_inplace_arg(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             left_arg = values.get("left_arg")
             right_arg = values.get("right_arg")
@@ -168,7 +165,7 @@ class InplacableBinaryOpParams(
             0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
         )
 
-    def _carried_arguments(self) -> Tuple[Optional[LeftDataT], Optional[RightDataT]]:
+    def _carried_arguments(self) -> tuple[Optional[LeftDataT], Optional[RightDataT]]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
             self.left_arg, RegisterArithmeticInfo
         ):
@@ -366,7 +363,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         )
 
     def _get_output_size(
-        self, bounds: Tuple[float, float], fraction_places: int
+        self, bounds: tuple[float, float], fraction_places: int
     ) -> int:
         if isinstance(self.right_arg, float) and self.effective_right_arg == 0:
             assert isinstance(self.effective_left_arg, RegisterArithmeticInfo)
@@ -477,8 +474,8 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     @staticmethod
     def _get_bounds(
-        args: Tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
-    ) -> Tuple[float, float]:
+        args: tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
+    ) -> tuple[float, float]:
         extremal_values = [
             left * right
             for left in argument_utils.bounds(args[0])
@@ -524,7 +521,7 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     @staticmethod
     def _get_output_size(
-        bounds: Tuple[float, float],
+        bounds: tuple[float, float],
         fraction_places: int,
         left_arg: Union[RegisterArithmeticInfo, float],
         right_arg: Union[RegisterArithmeticInfo, float],
@@ -603,7 +600,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
             * self.right_arg
         )
 
-    def _get_result_bounds(self) -> Tuple[float, float]:
+    def _get_result_bounds(self) -> tuple[float, float]:
         bounds = [
             number_utils.limit_fraction_places(
                 bound, machine_precision=self.machine_precision
@@ -644,7 +641,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
 
     def _get_inner_action_garbage_size(
         self,
-        action_type: Union[Type["Power"], Type[Multiplier]],
+        action_type: Union[type["Power"], type[Multiplier]],
         *,
         arg: RegisterArithmeticInfo,
         action_right_arg: RegisterOrConst,

classiq/interface/generator/arith/extremum_operations.py

@@ -1,5 +1,6 @@
 import abc
-from typing import Any, Dict, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 import pydantic
 
@@ -26,7 +27,7 @@ class Extremum(ArithmeticOperationParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_one_is_register(cls, values: Any) -> Dict[str, Any]:
+    def _validate_one_is_register(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             left_arg = values.get("left_arg")
             right_arg = values.get("right_arg")

classiq/interface/generator/arith/logical_ops.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Optional
+from collections.abc import Iterable
+from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict
@@ -17,11 +18,11 @@ def get_arg_name(idx: int) -> str:
 
 
 class LogicalOps(ArithmeticOperationParams):
-    args: List[RegisterOrConst]
+    args: list[RegisterOrConst]
     target: Optional[RegisterArithmeticInfo]
-    _should_invert_node_list: List[str] = pydantic.PrivateAttr(default_factory=list)
+    _should_invert_node_list: list[str] = pydantic.PrivateAttr(default_factory=list)
 
-    def update_should_invert_node_list(self, invert_args: List[str]) -> None:
+    def update_should_invert_node_list(self, invert_args: list[str]) -> None:
         self._should_invert_node_list.extend(invert_args)
 
     @pydantic.field_validator("output_size")
@@ -34,8 +35,8 @@ class LogicalOps(ArithmeticOperationParams):
     @pydantic.field_validator("args")
     @classmethod
     def _validate_inputs_sizes(
-        cls, arguments: List[RegisterOrConst]
-    ) -> List[RegisterOrConst]:
+        cls, arguments: list[RegisterOrConst]
+    ) -> list[RegisterOrConst]:
         for arg_idx, arg in enumerate(arguments):
             if isinstance(arg, RegisterArithmeticInfo) and not arg.is_boolean_register:
                 raise ClassiqValueError(

classiq/interface/generator/arith/number_utils.py

@@ -1,4 +1,4 @@
-from typing import Final, Tuple, Union
+from typing import Final, Union
 
 MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
@@ -40,7 +40,7 @@ def _get_fraction_places(*, binary_value: str) -> int:
     return fraction_places
 
 
-def get_int_representation_and_fraction_places(float_value: float) -> Tuple[int, int]:
+def get_int_representation_and_fraction_places(float_value: float) -> tuple[int, int]:
     int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0, 0
@@ -113,6 +113,6 @@ def limit_fraction_places(number: float, machine_precision: int) -> float:
 
 
 def bounds_cut(
-    bounds1: Tuple[float, float], bounds2: Tuple[float, float]
-) -> Tuple[float, float]:
+    bounds1: tuple[float, float], bounds2: tuple[float, float]
+) -> tuple[float, float]:
     return max(min(bounds1), min(bounds2)), min(max(bounds1), max(bounds2))

classiq/interface/generator/arith/register_user_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict
@@ -24,7 +24,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _remove_name(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         if isinstance(values, dict):
             values = values.copy()
         elif hasattr(values, "__dict__"):
@@ -40,7 +40,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     @staticmethod
     def get_maximal_bounds(
         *, size: int, is_signed: bool, fraction_places: int
-    ) -> Tuple[float, float]:
+    ) -> tuple[float, float]:
         lb = 0 if not is_signed else -(2 ** (size - 1))
         ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
         fraction_factor = float(2**-fraction_places)
@@ -106,7 +106,7 @@ class RegisterUserInput(RegisterArithmeticInfo):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _remove_name(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         return values
 
     def revalued(self, **kwargs: Any) -> "RegisterUserInput":

classiq/interface/generator/arith/unary_ops.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Final, Iterable, Optional
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Final, Optional
 
 import pydantic
 from pydantic import ConfigDict

classiq/interface/generator/builtin_api_builder.py

@@ -1,4 +1,5 @@
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,

classiq/interface/generator/circuit_code/circuit_code.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional
+from typing import Optional
 
 import pydantic
 
@@ -15,14 +15,14 @@ from classiq.interface.generator.model.preferences.preferences import QuantumFor
 
 
 class CircuitCodeInterface(pydantic.BaseModel):
-    outputs: Dict[QuantumFormat, Code]
+    outputs: dict[QuantumFormat, Code]
     qasm_version: QasmVersion
 
     @pydantic.field_validator("outputs")
     @classmethod
     def reformat_long_string_output_formats(
-        cls, outputs: Dict[QuantumFormat, str]
-    ) -> Dict[QuantumFormat, LongStr]:
+        cls, outputs: dict[QuantumFormat, str]
+    ) -> dict[QuantumFormat, LongStr]:
         return {key: LongStr(value) for key, value in outputs.items()}
 
     @property

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -1,5 +1,3 @@
-from typing import Dict, Tuple
-
 from typing_extensions import TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
@@ -8,14 +6,14 @@ from classiq.interface.generator.model.preferences.preferences import QuantumFor
 from classiq.interface.hardware import Provider
 
 Code: TypeAlias = str
-CodeAndSyntax: TypeAlias = Tuple[Code, QuantumInstructionSet]
+CodeAndSyntax: TypeAlias = tuple[Code, QuantumInstructionSet]
 
-INSTRUCTION_SET_TO_FORMAT: Dict[QuantumInstructionSet, QuantumFormat] = {
+INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.QASM: QuantumFormat.QASM,
     QuantumInstructionSet.QSHARP: QuantumFormat.QSHARP,
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
 }
-VENDOR_TO_INSTRUCTION_SET: Dict[Provider, QuantumInstructionSet] = {
+VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
     Provider.CLASSIQ: QuantumInstructionSet.QASM,
     Provider.IONQ: QuantumInstructionSet.IONQ,
     Provider.AZURE_QUANTUM: QuantumInstructionSet.QSHARP,

classiq/interface/generator/complex_type.py

@@ -1,8 +1,7 @@
-from typing import Union
+from typing import Annotated, Union
 
 from pydantic import PlainSerializer, PlainValidator
 from pydantic.json_schema import WithJsonSchema
-from typing_extensions import Annotated
 
 
 def validate_complex(v: Union[complex, str]) -> complex:

classiq/interface/generator/control_state.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -28,7 +28,7 @@ class ControlState(BaseModel):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_control(cls, values: Any) -> Dict[str, Any]:
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             num_ctrl_qubits: int = (
                 values.get("num_ctrl_qubits", _DEFAULT_NUM_CONTROL_QUBITS) or 0

classiq/interface/generator/custom_ansatz.py

@@ -1,5 +1,3 @@
-from typing import Dict, Type
-
 import pydantic
 
 from classiq.interface.enum_utils import StrEnum
@@ -22,7 +20,7 @@ class CustomAnsatzType(StrEnum):
     RandomTwoQubitGates = "RandomTwoQubitGates"
 
 
-CUSTOM_ANSATZ_ARGS_MAPPING: Dict[CustomAnsatzType, Type[pydantic.BaseModel]] = {
+CUSTOM_ANSATZ_ARGS_MAPPING: dict[CustomAnsatzType, type[pydantic.BaseModel]] = {
     CustomAnsatzType.TwoLocal: TwoLocalArgs,
     CustomAnsatzType.SeparateU3: SeparateU3Args,
     CustomAnsatzType.Hypercube: HypercubeArgs,

classiq/interface/generator/distance.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import numpy as np
 
 # Taken and modified from quantum_tsp_tutorials repository of mstechly in github.
@@ -10,7 +8,7 @@ def _distance_between_points(point_1: np.ndarray, point_2: np.ndarray) -> float:
     return float(np.linalg.norm(point_1 - point_2))
 
 
-def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
+def get_distance_matrix(cities: np.ndarray) -> list[list[float]]:
     number_of_cities = len(cities)
     matrix = np.zeros((number_of_cities, number_of_cities))
     for i in range(number_of_cities):
@@ -20,14 +18,14 @@ def get_distance_matrix(cities: np.ndarray) -> List[List[float]]:
     return matrix.tolist()
 
 
-def get_rand_euclidean_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_euclidean_distance_matrix(num_points: int) -> list[list[float]]:
     _points_array_dim = 2
     points = np.random.rand(num_points, _points_array_dim)
     distance_matrix = get_distance_matrix(points)
     return distance_matrix
 
 
-def get_rand_distance_matrix(num_points: int) -> List[List[float]]:
+def get_rand_distance_matrix(num_points: int) -> list[list[float]]:
     distance_matrix = np.random.rand(num_points, num_points)
     distance_matrix *= 0.5
     distance_matrix += distance_matrix.T

classiq/interface/generator/excitations.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Union
+from collections.abc import Iterable
+from typing import Union
 
 EXCITATIONS_TYPE = Union[str, int, Iterable[int], Iterable[str]]
-EXCITATIONS_TYPE_EXACT = List[int]
+EXCITATIONS_TYPE_EXACT = list[int]

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,11 +1,9 @@
-from typing import Dict
-
 from classiq.interface.generator.types.builtin_enum_declarations import (
     FinanceFunctionType,
 )
 
 
-def get_finance_function_dict() -> Dict[str, "FinanceFunctionType"]:
+def get_finance_function_dict() -> dict[str, "FinanceFunctionType"]:
     return {
         "var": FinanceFunctionType.VAR,
         "expected shortfall": FinanceFunctionType.SHORTFALL,

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,6 +1,7 @@
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Mapping, Optional, Type
+from typing import Any, Optional
 
 from sympy import Expr
 from typing_extensions import get_args
@@ -19,7 +20,7 @@ from classiq.interface.generator.expressions.handle_identifier import HandleIden
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self, constant_type: Optional[Type] = None) -> bool:
+    def is_constant(self, constant_type: Optional[type] = None) -> bool:
         if self.value is None:
             return False
 
@@ -28,7 +29,7 @@ class EvaluatedExpression:
             get_args(RuntimeConstant) if constant_type is None else constant_type,
         )
 
-    def as_constant_type(self, constant_type: Type) -> Any:
+    def as_constant_type(self, constant_type: type) -> Any:
         if not self.is_constant():
             raise ClassiqValueError(
                 f"Invalid access to expression {self.value!r} as {constant_type}"

classiq/interface/generator/expressions/expression.py

@@ -1,6 +1,6 @@
 import ast
-import sys
-from typing import Any, Mapping, Optional, Type
+from collections.abc import Mapping
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
@@ -45,14 +45,13 @@ class Expression(HashableASTNode):
     @pydantic.field_validator("expr")
     @classmethod
     def format_expression(cls, expr: str) -> str:
-        if sys.version_info >= (3, 9):
-            expr = ast.unparse(ast.parse(expr))
+        expr = ast.unparse(ast.parse(expr))
         return expr
 
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 
-    def as_constant(self, constant_type: Type) -> Any:
+    def as_constant(self, constant_type: type) -> Any:
         return self.value.as_constant_type(constant_type)
 
     def to_int_value(self) -> int:

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Final, FrozenSet, Set
+from typing import Final
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -11,12 +11,12 @@ from classiq.interface.generator.function_params import NAME_REGEX
 
 SUPPORTED_VAR_NAMES_REG = NAME_REGEX
 
-SUPPORTED_FUNC_NAMES: Set[str] = (
+SUPPORTED_FUNC_NAMES: set[str] = (
     {"or", "and"}
     .union(DEFAULT_SUPPORTED_FUNC_NAMES)
     .union(set(SYMPY_SUPPORTED_EXPRESSIONS))
 )
 BOOLEAN_LITERALS = {"True", "False"}
-FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
 CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
-RESERVED_EXPRESSIONS: FrozenSet[str] = frozenset({"i"})
+RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Mapping, Union
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union
 
 from sympy import Integer
 

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -1,4 +1,5 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 from sympy import Symbol
 

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding

classiq/interface/generator/expressions/qmod_struct_instance.py

@@ -1,5 +1,6 @@
 import types
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -1,7 +1,5 @@
-from typing import List
-
-BASIC_ARITHMETIC_OPERATORS: List[str] = ["+", "-", "*", "/", "%"]
-MATHEMATICAL_FUNCTIONS: List[str] = [
+BASIC_ARITHMETIC_OPERATORS: list[str] = ["+", "-", "*", "/", "%"]
+MATHEMATICAL_FUNCTIONS: list[str] = [
     "sin",
     "cos",
     "tan",
@@ -36,7 +34,7 @@ MATHEMATICAL_FUNCTIONS: List[str] = [
     "Min",
     "mod_inverse",
 ]
-SPECIAL_FUNCTIONS: List[str] = [
+SPECIAL_FUNCTIONS: list[str] = [
     "erf",
     "erfc",
     "gamma",
@@ -57,8 +55,8 @@ SPECIAL_FUNCTIONS: List[str] = [
     "euler",
     "catalan",
 ]
-PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-NUMERIC_CONSTANTS: List[str] = [
+PIECEWISE_FUNCTIONS: list[str] = ["Piecewise", "Heaviside"]
+NUMERIC_CONSTANTS: list[str] = [
     "pi",
     "E",
     "I",
@@ -66,11 +64,11 @@ NUMERIC_CONSTANTS: List[str] = [
     "EulerGamma",
     "Catalan",
 ]
-BOOLEAN_CONSTANTS: List[str] = ["true", "false"]
-CONSTANTS: List[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
+BOOLEAN_CONSTANTS: list[str] = ["true", "false"]
+CONSTANTS: list[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
 
-DATA_TYPES: List[str] = ["Matrix"]
-LOGIC_OPERATORS: List[str] = [
+DATA_TYPES: list[str] = ["Matrix"]
+LOGIC_OPERATORS: list[str] = [
     "And",
     "Or",
     "Not",
@@ -80,9 +78,9 @@ LOGIC_OPERATORS: List[str] = [
     "Nand",
     "Nor",
 ]
-RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
+RELATIONAL_OPERATORS: list[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
 
-SYMPY_SUPPORTED_EXPRESSIONS: List[str] = (
+SYMPY_SUPPORTED_EXPRESSIONS: list[str] = (
     BASIC_ARITHMETIC_OPERATORS
     + MATHEMATICAL_FUNCTIONS
     + SPECIAL_FUNCTIONS