classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -1,7 +1,7 @@
 import abc
 import ast
 import re
-from typing import Any, Dict, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import networkx as nx
 import pydantic
@@ -41,16 +41,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     uncomputation_method: UncomputationMethods = UncomputationMethods.optimized
     machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
-    definitions: Dict[str, ValidDefinitions]
+    definitions: dict[str, ValidDefinitions]
     qubit_count: Optional[pydantic.NonNegativeInt] = None
 
-    def _get_literal_set(self) -> Set[str]:
+    def _get_literal_set(self) -> set[str]:
         return _extract_literals(self.expression)
 
     @classmethod
     def _validate_expression_literals_and_definitions(
-        cls, definitions: Dict[str, ValidDefinitions], expression: PydanticExpressionStr
-    ) -> Dict[str, ValidDefinitions]:
+        cls, definitions: dict[str, ValidDefinitions], expression: PydanticExpressionStr
+    ) -> dict[str, ValidDefinitions]:
         literals = _extract_literals(expression)
 
         forbidden = literals.intersection(FORBIDDEN_LITERALS)
@@ -69,13 +69,13 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_expression(cls, values: Any) -> Dict[str, Any]:
+    def _validate_expression(cls, values: Any) -> dict[str, Any]:
         if not isinstance(values, dict):
             return values
         expression_adapter: TypeAdapter = TypeAdapter(Optional[PydanticExpressionStr])
         expression = expression_adapter.validate_python(values.get("expression"))
         definitions_adapter: TypeAdapter = TypeAdapter(
-            Optional[Dict[str, ValidDefinitions]]
+            Optional[dict[str, ValidDefinitions]]
         )
         definition_dict = values.get("definitions")
         if (
@@ -148,16 +148,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         pass
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         pass
 
     @classmethod
     def _replace_const_definitions_in_expression(
         cls,
         expression: str,
-        definitions: Dict[str, ValidDefinitions],
+        definitions: dict[str, ValidDefinitions],
         machine_precision: int,
-    ) -> Tuple[str, Dict[str, RegisterArithmeticInfo]]:
+    ) -> tuple[str, dict[str, RegisterArithmeticInfo]]:
         new_definitions = dict()
         for var_name, value in definitions.items():
             if isinstance(value, RegisterArithmeticInfo):
@@ -182,5 +182,5 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         return re.sub(r"\b" + var + r"\b", str(value), expression)
 
 
-def _extract_literals(expression: str) -> Set[str]:
+def _extract_literals(expression: str) -> set[str]:
     return set(re.findall(SUPPORTED_VAR_NAMES_REG, expression)) - SUPPORTED_FUNC_NAMES

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -1,6 +1,7 @@
 import ast
 from _ast import AST
-from typing import Collection, List, Optional, Set, Tuple, Type, Union, cast
+from collections.abc import Collection
+from typing import Optional, Union, cast
 
 import networkx as nx
 
@@ -28,9 +29,9 @@ Node = Union[str, float, int]
 class ExpressionVisitor(ExpressionValidator):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
     ) -> None:
         super().__init__(supported_nodes, expression_type, supported_functions)
         self.graph = nx.DiGraph()
@@ -90,8 +91,8 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[Tuple[Node, str]]
-    ) -> List[Tuple[Node, str]]:
+        in_edges: Collection[tuple[Node, str]]
+    ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,
             key=lambda edge_tuple: isinstance(edge_tuple[0], str),  # vars before consts
@@ -134,9 +135,9 @@ class InDegreeLimiter:
 def parse_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
 ) -> nx.DiGraph:
     supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,7 +1,7 @@
 import ast
 import re
 from _ast import AST
-from typing import Any, Dict, Optional, Set, Tuple, Type, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import TypeAlias, get_args
 
@@ -11,7 +11,7 @@ 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] = {"CLShift", "CRShift", "min", "max"}
 
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
 IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
@@ -19,7 +19,7 @@ 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."
 )
-ValidKeyValuePairs: TypeAlias = Dict[str, Set[str]]
+ValidKeyValuePairs: TypeAlias = dict[str, set[str]]
 
 SupportedNodesTypes = Union[
     ast.Expression,
@@ -68,9 +68,9 @@ def _is_constant(expr: str) -> bool:
 class ExpressionValidator(ast.NodeVisitor):
     def __init__(
         self,
-        supported_nodes: Tuple[Type[AST], ...],
+        supported_nodes: tuple[type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
-        supported_functions: Optional[Set[str]] = None,
+        supported_functions: Optional[set[str]] = None,
         mode: str = "eval",
     ) -> None:
         super().__init__()
@@ -108,7 +108,7 @@ class ExpressionValidator(ast.NodeVisitor):
         return self._ast_obj
 
     @staticmethod
-    def _check_repeated_variables(variables: Tuple[Any, Any]) -> None:
+    def _check_repeated_variables(variables: tuple[Any, Any]) -> None:
         if (
             all(isinstance(var, ast.Name) for var in variables)
             and variables[0].id == variables[1].id
@@ -186,9 +186,9 @@ class ExpressionValidator(ast.NodeVisitor):
 def validate_expression(
     expression: str,
     *,
-    supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
+    supported_nodes: tuple[type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
-    supported_functions: Optional[Set[str]] = None,
+    supported_functions: Optional[set[str]] = None,
     mode: str = "eval",
 ) -> ast.AST:
     supported_functions = supported_functions or set(SYMPY_SUPPORTED_EXPRESSIONS).union(

classiq/interface/generator/arith/arithmetic_operations.py

@@ -1,5 +1,6 @@
 import abc
-from typing import ClassVar, Final, Iterable, Optional, Tuple
+from collections.abc import Iterable
+from typing import ClassVar, Final, Optional
 
 import pydantic
 
@@ -43,8 +44,8 @@ class ArithmeticOperationParams(FunctionParams):
         return self.output_size is None
 
     def _legal_bounds(
-        self, suggested_bounds: Tuple[float, float], max_bounds: Tuple[float, float]
-    ) -> Optional[Tuple[float, float]]:
+        self, suggested_bounds: tuple[float, float], max_bounds: tuple[float, float]
+    ) -> Optional[tuple[float, float]]:
         if self.output_size is None or (
             suggested_bounds[0] >= max_bounds[0]
             and suggested_bounds[1] <= max_bounds[1]

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]