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

classiq/interface/generator/grover_diffuser.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Set, Tuple, Union
+from typing import Any, Union
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -17,7 +17,7 @@ GroverStatePreparation = Union[StatePreparation, CustomFunction]
 
 
 class GroverDiffuser(FunctionParams):
-    variables: List[RegisterUserInput]
+    variables: list[RegisterUserInput]
     state_preparation: str = pydantic.Field(
         default="", description="State preparation function"
     )
@@ -32,7 +32,7 @@ class GroverDiffuser(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_state_preparation_name(cls, values: Any) -> Dict[str, Any]:
+    def _validate_state_preparation_name(cls, values: Any) -> dict[str, Any]:
         if (
             isinstance(values, dict)
             and isinstance(values.get("state_preparation_params"), CustomFunction)
@@ -45,7 +45,7 @@ class GroverDiffuser(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _parse_state_preparation(cls, values: Any) -> Dict[str, Any]:
+    def _parse_state_preparation(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             parse_function_params_values(
                 values=values,
@@ -59,8 +59,8 @@ class GroverDiffuser(FunctionParams):
     @pydantic.field_validator("variables")
     @classmethod
     def _validate_variables(
-        cls, variables: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
+        cls, variables: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
         names = {reg.name for reg in variables}
         assert len(variables) == len(names), "Repeating names not allowed"
         return variables
@@ -89,5 +89,5 @@ class GroverDiffuser(FunctionParams):
         return state_preparation_params
 
     @staticmethod
-    def _names_and_sizes(transputs: ArithmeticIODict) -> Set[Tuple[str, int]]:
+    def _names_and_sizes(transputs: ArithmeticIODict) -> set[tuple[str, int]]:
         return {(name, reg.size) for name, reg in transputs.items()}

classiq/interface/generator/grover_operator.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -49,7 +49,7 @@ class GroverOperator(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _parse_oracle(cls, values: Any) -> Dict[str, Any]:
+    def _parse_oracle(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             oracle_params = values.get("oracle_params")
             if isinstance(oracle_params, dict):

classiq/interface/generator/hardware/hardware_data.py

@@ -1,6 +1,7 @@
 import itertools
 from collections import defaultdict
-from typing import Any, Dict, List, MutableSet, Optional
+from collections.abc import MutableSet
+from typing import Any, Optional
 
 import pydantic
 from typing_extensions import Self
@@ -16,7 +17,7 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 BACKEND_VALIDATION_ERROR_MESSAGE = (
     "Backend service provider and backend name should be specified together."
 )
@@ -41,7 +42,7 @@ class HardwareData(pydantic.BaseModel):
             that both qubits in each pair can act as control and target. Defaults to True.
     """
 
-    basis_gates: List[str] = pydantic.Field(
+    basis_gates: list[str] = pydantic.Field(
         default=list(),
         description="The basis gates of the hardware. "
         "This set will be used during the model optimization. "
@@ -129,7 +130,7 @@ class CustomHardwareSettings(HardwareData):
 
     @pydantic.field_validator("basis_gates", mode="after")
     @classmethod
-    def validate_basis_gates(cls, basis_gates: List[str]) -> List[TranspilerBasisGates]:
+    def validate_basis_gates(cls, basis_gates: list[str]) -> list[TranspilerBasisGates]:
         valid_gates = list(TranspilerBasisGates)
         invalid_gates = [gate for gate in basis_gates if gate not in valid_gates]
         if invalid_gates:
@@ -154,7 +155,7 @@ class CustomHardwareSettings(HardwareData):
 
 def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
     nodes: MutableSet[int] = set()
-    node_to_neighbors: Dict[int, MutableSet[int]] = defaultdict(set)
+    node_to_neighbors: dict[int, MutableSet[int]] = defaultdict(set)
     for edge in connectivity_map:
         nodes.add(edge[0])
         nodes.add(edge[1])
@@ -167,7 +168,7 @@ def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
 
 
 def _node_dfs(
-    node: int, node_to_neighbors: Dict[int, MutableSet[int]], visited: MutableSet[int]
+    node: int, node_to_neighbors: dict[int, MutableSet[int]], visited: MutableSet[int]
 ) -> None:
     visited.add(node)
     neighbors = node_to_neighbors[node]

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -18,7 +18,7 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 
 
 class SupportedConnectivityMaps(StrEnum):
@@ -51,11 +51,11 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         default=1, description="Number of layers in the Ansatz"
     )
 
-    one_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    one_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["x", "ry"],
         description='List of gates for the one qubit gates layer, e.g. ["x", "ry"]',
     )
-    two_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    two_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["cx"],
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
@@ -107,8 +107,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     @pydantic.field_validator("one_qubit_gates")
     @classmethod
     def validate_one_qubit_gates(
-        cls, one_qubit_gates: Union[str, List[str]]
-    ) -> Union[str, List[str]]:
+        cls, one_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         one_qubit_gates_list = (
             [one_qubit_gates] if isinstance(one_qubit_gates, str) else one_qubit_gates
         )
@@ -120,8 +120,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     @pydantic.field_validator("two_qubit_gates")
     @classmethod
     def validate_two_qubit_gates(
-        cls, two_qubit_gates: Union[str, List[str]]
-    ) -> Union[str, List[str]]:
+        cls, two_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         two_qubit_gates_list = (
             [two_qubit_gates] if isinstance(two_qubit_gates, str) else two_qubit_gates
         )

classiq/interface/generator/identity.py

@@ -1,17 +1,16 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Annotated
 
 import pydantic
 from pydantic import Field
-from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import FunctionParams
 
 if TYPE_CHECKING:
-    NonEmptyRegisterUserInputList = List[RegisterUserInput]
+    NonEmptyRegisterUserInputList = list[RegisterUserInput]
 else:
     NonEmptyRegisterUserInputList = Annotated[
-        List[RegisterUserInput], Field(min_length=1)
+        list[RegisterUserInput], Field(min_length=1)
     ]
 
 
@@ -23,8 +22,8 @@ class Identity(FunctionParams):
     @pydantic.field_validator("arguments")
     @classmethod
     def _validate_argument_names(
-        cls, arguments: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
+        cls, arguments: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
         return [
             arg if arg.name else arg.revalued(name=cls._get_default_arg_name(index))
             for index, arg in enumerate(arguments)

classiq/interface/generator/linear_pauli_rotations.py

@@ -1,8 +1,8 @@
-from typing import TYPE_CHECKING, Any, List
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
 from pydantic import StringConstraints
-from typing_extensions import Annotated, Self
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
@@ -51,19 +51,19 @@ class LinearPauliRotations(function_params.FunctionParams):
     num_state_qubits: pydantic.PositiveInt = pydantic.Field(
         description="The number of input qubits"
     )
-    bases: List[PydanticPauliBasisStr] = pydantic.Field(
+    bases: list[PydanticPauliBasisStr] = pydantic.Field(
         description="The types of Pauli rotations ('X', 'Y', 'Z')."
     )
-    slopes: List[float] = pydantic.Field(
+    slopes: list[float] = pydantic.Field(
         description="The slopes of the controlled rotations."
     )
-    offsets: List[float] = pydantic.Field(
+    offsets: list[float] = pydantic.Field(
         description="The offsets of the controlled rotations."
     )
 
     @pydantic.field_validator("bases", "slopes", "offsets", mode="before")
     @classmethod
-    def as_list(cls, v: Any) -> List[Any]:
+    def as_list(cls, v: Any) -> list[Any]:
         if not isinstance(v, list):
             v = [v]
         res = []

classiq/interface/generator/mcu.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, cast
+from typing import Any, Optional, cast
 
 import pydantic
 
@@ -53,7 +53,7 @@ class Mcu(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_control(cls, values: Any) -> Dict[str, Any]:
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
         num_ctrl_qubits = values.get("num_ctrl_qubits")
         ctrl_state = values.get("ctrl_state")
 

classiq/interface/generator/mcx.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -17,7 +17,7 @@ class Mcx(FunctionParams):
     multi-controlled x-gate
     """
 
-    arguments: List[RegisterUserInput] = pydantic.Field(
+    arguments: list[RegisterUserInput] = pydantic.Field(
         default_factory=list, description="registers describing the state (ordered)"
     )
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
@@ -31,9 +31,9 @@ class Mcx(FunctionParams):
     @pydantic.field_validator("arguments")
     @classmethod
     def _validate_argument_names(
-        cls, arguments: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
-        register_name_list: List[Optional[str]] = [arg.name for arg in arguments]
+        cls, arguments: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
+        register_name_list: list[Optional[str]] = [arg.name for arg in arguments]
         if None in register_name_list:
             raise ClassiqValueError("All registers must be named")
         if len(set(register_name_list)) != len(register_name_list):
@@ -42,7 +42,7 @@ class Mcx(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_sizes(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def _validate_sizes(cls, values: dict[str, Any]) -> dict[str, Any]:
         arguments_size = sum(arg.size for arg in values.get("arguments", list()))
         num_ctrl_qubits = values.get("num_ctrl_qubits")
         if not num_ctrl_qubits:

classiq/interface/generator/model/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.generator.model.constraints import (
     Constraints,
     OptimizationParameter,
@@ -10,7 +8,7 @@ from classiq.interface.generator.model.preferences import (
     Preferences,
 )
 
-__all__: List[str] = [
+__all__: list[str] = [
     "Constraints",
     "Preferences",
     "CustomHardwareSettings",

classiq/interface/generator/model/constraints.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -59,7 +59,7 @@ class Constraints(BaseModel):
     )
     max_depth: Optional[pydantic.PositiveInt] = None
 
-    max_gate_count: Dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
+    max_gate_count: dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
         pydantic.Field(default_factory=lambda: defaultdict(int))
     )
 

classiq/interface/generator/model/model.py

@@ -1,5 +1,4 @@
 from abc import ABC
-from typing import List
 
 import pydantic
 
@@ -24,22 +23,22 @@ class ClassiqBaseModel(VersionedModel, ABC):
     All the relevant data for evaluating execution in one place.
     """
 
-    enums: List[EnumDeclaration] = pydantic.Field(
+    enums: list[EnumDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined enums",
     )
 
-    types: List[StructDeclaration] = pydantic.Field(
+    types: list[StructDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined structs",
     )
 
-    qstructs: List[QStructDeclaration] = pydantic.Field(
+    qstructs: list[QStructDeclaration] = pydantic.Field(
         default_factory=list,
         description="user-defined quantum structs",
     )
 
-    constants: List[Constant] = pydantic.Field(
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -53,7 +52,7 @@ class ClassiqBaseModel(VersionedModel, ABC):
 
     @pydantic.field_validator("types")
     @classmethod
-    def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
+    def types_validator(cls, types: list[StructDeclaration]) -> list[StructDeclaration]:
         if not is_list_unique([struct_type.name for struct_type in types]):
             raise ClassiqValueError(TYPE_LIBRARY_DUPLICATED_TYPE_NAMES)
 

classiq/interface/generator/model/preferences/preferences.py

@@ -1,9 +1,10 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 
 import pydantic
 from pydantic import Field
 from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Annotated, Self, TypeAlias
+from typing_extensions import Self, TypeAlias
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
@@ -47,7 +48,7 @@ class QuantumFormat(StrEnum):
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
 
 
-_SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
+_SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {
     Provider.CLASSIQ: QuantumFormat.QASM,
     Provider.IONQ: QuantumFormat.IONQ,
     Provider.AZURE_QUANTUM: QuantumFormat.QSHARP,
@@ -56,10 +57,10 @@ _SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
 }
 
 if TYPE_CHECKING:
-    PydanticConstrainedQuantumFormatList = List[QuantumFormat]
+    PydanticConstrainedQuantumFormatList = list[QuantumFormat]
 else:
     PydanticConstrainedQuantumFormatList = Annotated[
-        List[QuantumFormat], Field(min_length=1, max_length=len(QuantumFormat))
+        list[QuantumFormat], Field(min_length=1, max_length=len(QuantumFormat))
     ]
 
 
@@ -215,7 +216,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
 
     @pydantic.field_validator("output_format", mode="before")
     @classmethod
-    def make_output_format_list(cls, output_format: Any) -> List:
+    def make_output_format_list(cls, output_format: Any) -> list:
         if not isinstance(output_format, Sequence) or isinstance(output_format, str):
             output_format = [output_format]
 

classiq/interface/generator/model/quantum_register.py

@@ -1,12 +1,10 @@
 import itertools
 import sys
+from collections.abc import Iterator
+from types import GenericAlias as TypesGenericAlias
 from typing import (  # type: ignore[attr-defined]
     Any,
-    Dict,
-    Iterator,
-    List,
     Optional,
-    Type,
     Union,
     _GenericAlias,
 )
@@ -19,9 +17,6 @@ from classiq.interface.generator.arith.register_user_input import (
 from classiq.interface.generator.function_params import ArithmeticIODict, IOName
 from classiq.interface.generator.register_role import RegisterRole
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias as TypesGenericAlias
-
 
 # This class is used for QReg, to support type-hint initialization
 #   Due to the `size` property of QReg
@@ -90,7 +85,7 @@ class QReg:
         return super.__hash__(self)
 
     @classmethod
-    def _from_qubits(cls, qubits: List[Qubit]) -> "QReg":
+    def _from_qubits(cls, qubits: list[Qubit]) -> "QReg":
         if (
             not isinstance(qubits, list)
             or not all(isinstance(qubit, Qubit) for qubit in qubits)
@@ -141,7 +136,7 @@ class QReg:
         return len(self._qubits)
 
     @property
-    def qubits(self) -> List[Qubit]:
+    def qubits(self) -> list[Qubit]:
         return self._qubits
 
     def __class_getitem__(cls, params: Any) -> QRegGenericAlias:
@@ -231,7 +226,7 @@ _PROP_TO_QREG_TYPE = {
 }
 
 
-def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> Type["QReg"]:
+def _get_qreg_type_from_arithmetic_info(info: RegisterArithmeticInfo) -> type["QReg"]:
     return _PROP_TO_QREG_TYPE[(info.is_signed, info.is_frac)]
 
 
@@ -247,7 +242,7 @@ def _get_qreg_generic_alias_from_arithmetic_info(
 
 def get_type_and_size_dict(
     arithmetic_info_dict: ArithmeticIODict,
-) -> Dict[IOName, QRegGenericAlias]:
+) -> dict[IOName, QRegGenericAlias]:
     return {
         io_name: _get_qreg_generic_alias_from_arithmetic_info(info)
         for io_name, info in arithmetic_info_dict.items()

classiq/interface/generator/oracles/arithmetic_oracle.py

@@ -1,6 +1,5 @@
 import ast
 import re
-from typing import Dict
 
 import numexpr  # type: ignore[import]
 
@@ -61,7 +60,7 @@ class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
 
     @staticmethod
     def _simplify_negations_of_boolean_variables(
-        expression: str, input_definitions: Dict[str, RegisterArithmeticInfo]
+        expression: str, input_definitions: dict[str, RegisterArithmeticInfo]
     ) -> str:
         for var_name in input_definitions:
             if getattr(input_definitions[var_name], "size", 0) == 1:

classiq/interface/generator/oracles/custom_oracle.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import pydantic
 
@@ -24,7 +24,7 @@ class CustomOracle(OracleABC[QubitState]):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _parse_oracle(cls, values: Any) -> Dict[str, Any]:
+    def _parse_oracle(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             parse_function_params_values(
                 values=values,

classiq/interface/generator/oracles/oracle_abc.py

@@ -1,5 +1,6 @@
 import abc
-from typing import Dict, Generic, List, Optional, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Generic, Optional, TypeVar
 
 import numpy as np
 
@@ -11,8 +12,8 @@ from classiq.interface.generator.generated_circuit_data import IOQubitMapping
 
 ProblemResultType = TypeVar("ProblemResultType")
 
-VariableBinResultMap = Dict[str, State]
-VariableTypedResultMap = Dict[str, ProblemResultType]
+VariableBinResultMap = dict[str, State]
+VariableTypedResultMap = dict[str, ProblemResultType]
 
 
 class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
@@ -58,7 +59,7 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
     ) -> bool:
         pass
 
-    def variables(self) -> List[RegisterUserInput]:
+    def variables(self) -> list[RegisterUserInput]:
         return [
             RegisterUserInput.from_arithmetic_info(info=info, name=name)
             for name, info in self._inputs.items()
@@ -71,5 +72,5 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
             )
 
 
-def _reverse_endianness(indices: Sequence[int], state_length: int) -> List[int]:
+def _reverse_endianness(indices: Sequence[int], state_length: int) -> list[int]:
     return [state_length - 1 - index for index in indices]

classiq/interface/generator/partitioned_register.py

@@ -1,6 +1,7 @@
 import itertools
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Iterator, List, Optional, Tuple
+from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
@@ -12,7 +13,7 @@ class PartitionedRegister:
 
     # There are up to num_qubits qubits within the partitions, with unique values from 0 to num_qubits-1
     num_qubits: int
-    partitions: Tuple[Tuple[int, ...], ...]
+    partitions: tuple[tuple[int, ...], ...]
 
     def __post_init__(self) -> None:
         if not self.partitions:
@@ -47,7 +48,7 @@ class PartitionedRegister:
         return RegisterPartition(self, _index=None)
 
     @property
-    def _leftover_qubits(self) -> Tuple[int, ...]:
+    def _leftover_qubits(self) -> tuple[int, ...]:
         total_qubits = set(itertools.chain.from_iterable(self.partitions))
         return tuple(
             qubit for qubit in range(self.num_qubits) if qubit not in total_qubits
@@ -59,7 +60,7 @@ class PartitionedRegister:
 
     def all_register_partitions(
         self, include_leftover_partition: bool = False
-    ) -> List["RegisterPartition"]:
+    ) -> list["RegisterPartition"]:
         all_partitions = [self.get_partition(i) for i in range(len(self.partitions))]
         if include_leftover_partition:
             all_partitions.append(self.leftover_partition)
@@ -82,7 +83,7 @@ class RegisterPartition:
             raise ClassiqValueError(message)
 
     @property
-    def qubits(self) -> Tuple[int, ...]:
+    def qubits(self) -> tuple[int, ...]:
         if self._index is None:
             return self.partitioned_register._leftover_qubits
         return self.partitioned_register.partitions[self._index]

classiq/interface/generator/piecewise_linear_amplitude_loading.py

@@ -1,5 +1,6 @@
 import math
-from typing import Any, Dict, Generic, List, Sequence, Tuple, TypeVar
+from collections.abc import Sequence
+from typing import Any, Generic, TypeVar
 
 import pydantic
 from pydantic import BaseModel, ConfigDict, Field, field_validator
@@ -26,7 +27,7 @@ class AffineMap(HashablePydanticBaseModel):
     def evaluate(self, x: float) -> float:
         return self.offset + self.slope * x
 
-    def image_bounds(self, domain_bounds: Tuple[float, float]) -> Tuple[float, float]:
+    def image_bounds(self, domain_bounds: tuple[float, float]) -> tuple[float, float]:
         return self.evaluate(domain_bounds[0]), self.evaluate(domain_bounds[1])
 
     model_config = ConfigDict(frozen=True)
@@ -50,8 +51,8 @@ class PiecewiseLinearAmplitudeLoadingABC(
     def _max_index(self) -> int:
         return 2**self.num_qubits - 1
 
-    def _get_image_bounds(self) -> Tuple[float, float]:
-        piece_bounds: Sequence[Tuple[float, float]] = [
+    def _get_image_bounds(self) -> tuple[float, float]:
+        piece_bounds: Sequence[tuple[float, float]] = [
             affine_map.image_bounds((self.breakpoints[idx], self.breakpoints[idx + 1]))
             for idx, affine_map in enumerate(self.affine_maps)
         ]
@@ -74,7 +75,7 @@ class PiecewiseLinearAmplitudeLoadingABC(
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_lengths(cls, values: Any) -> Dict[str, Any]:
+    def _validate_lengths(cls, values: Any) -> dict[str, Any]:
         breakpoints = values.get("breakpoints", list())
         affine_maps = values.get("affine_maps", list())
         num_qubits = values.get("num_qubits", int)
@@ -126,11 +127,11 @@ class PiecewiseLinearAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[float])
 
         a, b = self.breakpoints[0], self.breakpoints[-1]
 
-        normalized_breakpoints: List[int] = [
+        normalized_breakpoints: list[int] = [
             round(self._max_index * (point - a) / (b - a)) for point in self.breakpoints
         ]
 
-        normalized_affine_maps: List[AffineMap] = list()
+        normalized_affine_maps: list[AffineMap] = list()
         for affine_map in self.affine_maps:
             normalized_slope = (
                 2 * affine_map.slope * self.rescaling_factor * (b - a)

classiq/interface/generator/qpe.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict
@@ -52,7 +52,7 @@ class ExponentiationSpecification(pydantic.BaseModel):
         default=None,
         description="The scaling of the exponentiation functions.",
     )
-    max_depths: Optional[Tuple[pydantic.NonNegativeInt, ...]] = pydantic.Field(
+    max_depths: Optional[tuple[pydantic.NonNegativeInt, ...]] = pydantic.Field(
         default=None,
         description="The max_depth of each exponentiation function; overrides scaling.",
     )
@@ -103,7 +103,7 @@ class PhaseEstimation(FunctionParams):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_composite_name(cls, values: Any) -> Dict[str, Any]:
+    def _validate_composite_name(cls, values: Any) -> dict[str, Any]:
         if not isinstance(values, dict):
             return values
         unitary_params = values.get("unitary_params")
@@ -119,7 +119,7 @@ class PhaseEstimation(FunctionParams):
     @classmethod
     def _parse_function_params(
         cls, values: Any, info: ValidationInfo
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         vals = info.data.copy() if info.data else {}
         if isinstance(values, dict):
             vals = values