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

classiq/interface/generator/finance.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Tuple, Union
+from typing import Union
 
 import pydantic
 
@@ -90,7 +90,7 @@ class FinancePayoff(function_params.FunctionParams):
         description="The finance function to solve the model"
     )
     num_qubits: pydantic.PositiveInt
-    distribution_range: Tuple[float, float]
+    distribution_range: tuple[float, float]
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/function_param_library.py

@@ -1,19 +1,19 @@
-from typing import Iterable, Set, Type
+from collections.abc import Iterable
 
 from classiq.interface.generator.function_params import FunctionParams
 
 
 class FunctionParamLibrary:
-    def __init__(self, param_list: Iterable[Type[FunctionParams]]) -> None:
-        self._param_list: Set[Type[FunctionParams]] = set(param_list)
+    def __init__(self, param_list: Iterable[type[FunctionParams]]) -> None:
+        self._param_list: set[type[FunctionParams]] = set(param_list)
 
     @property
-    def param_list(self) -> Set[Type[FunctionParams]]:
+    def param_list(self) -> set[type[FunctionParams]]:
         return self._param_list.copy()
 
     # Private methods are for tests only
-    def _add(self, param: Type[FunctionParams]) -> None:
+    def _add(self, param: type[FunctionParams]) -> None:
         self._param_list.add(param)
 
-    def _remove(self, param: Type[FunctionParams]) -> None:
+    def _remove(self, param: type[FunctionParams]) -> None:
         self._param_list.discard(param)

classiq/interface/generator/function_params.py

@@ -1,16 +1,11 @@
 import ast
 import itertools
 import re
+from collections.abc import Collection, Iterable, Mapping
 from typing import (
+    Annotated,
     Any,
-    Collection,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
     Optional,
-    Set,
-    Type,
     Union,
     get_args,
 )
@@ -18,7 +13,6 @@ from typing import (
 import pydantic
 import sympy
 from pydantic import BeforeValidator, ConfigDict
-from typing_extensions import Annotated
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -35,7 +29,7 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 FunctionParamsDiscriminator = str
 
 IOName = PydanticNonEmptyString
-ArithmeticIODict = Dict[IOName, RegisterArithmeticInfo]
+ArithmeticIODict = dict[IOName, RegisterArithmeticInfo]
 
 DEFAULT_ZERO_NAME = "zero"
 DEFAULT_OUTPUT_NAME = "OUT"
@@ -114,7 +108,7 @@ GenerationExpressionSupportedNodeTypes = Union[
 
 
 def validate_expression_str(
-    expr_str: str, supported_functions: Optional[Set[str]] = None
+    expr_str: str, supported_functions: Optional[set[str]] = None
 ) -> None:
     # By default, no functions are allowed.
     supported_functions = supported_functions or set()
@@ -189,11 +183,11 @@ class FunctionParams(HashablePydanticBaseModel):
         return sum(reg.size for reg in self.outputs.values())
 
     @property
-    def _input_names(self) -> List[IOName]:
+    def _input_names(self) -> list[IOName]:
         return list(self._inputs.keys())
 
     @property
-    def _output_names(self) -> List[IOName]:
+    def _output_names(self) -> list[IOName]:
         return list(self._outputs.keys())
 
     def _create_zero_input_registers(self, names_and_sizes: Mapping[str, int]) -> None:
@@ -238,7 +232,7 @@ class FunctionParams(HashablePydanticBaseModel):
         return sum(reg.size if reg is not None else 0 for reg in registers)
 
     def _validate_io_names(self) -> None:
-        error_msg: List[str] = []
+        error_msg: list[str] = []
         error_msg += self._get_error_msg(self._inputs, BAD_INPUT_REGISTER_ERROR_MSG)
         error_msg += self._get_error_msg(self._outputs, BAD_OUTPUT_REGISTER_ERROR_MSG)
         if error_msg:
@@ -257,7 +251,7 @@ class FunctionParams(HashablePydanticBaseModel):
         if total_inputs_size != total_outputs_size:
             raise ClassiqValueError(REGISTER_SIZES_MISMATCH_ERROR_MSG)
 
-    def _get_error_msg(self, names: Iterable[IOName], msg: str) -> List[str]:
+    def _get_error_msg(self, names: Iterable[IOName], msg: str) -> list[str]:
         bad_names = [name for name in names if re.fullmatch(NAME_REGEX, name) is None]
         return [f"{msg}: {bad_names}"] if bad_names else []
 
@@ -272,10 +266,10 @@ def parse_function_params(
     *,
     params: Any,
     discriminator: Optional[Any],
-    param_classes: Collection[Type[FunctionParams]],
+    param_classes: Collection[type[FunctionParams]],
     no_discriminator_error: Exception,
     bad_function_error: Exception,
-    default_parser_class: Optional[Type[FunctionParams]] = None,
+    default_parser_class: Optional[type[FunctionParams]] = None,
 ) -> FunctionParams:  # Any is for use in pydantic validators.
     if not discriminator:
         raise no_discriminator_error
@@ -299,11 +293,11 @@ def parse_function_params(
 
 def parse_function_params_values(
     *,
-    values: Dict[str, Any],
+    values: dict[str, Any],
     params_key: str,
     discriminator_key: str,
-    param_classes: Collection[Type[FunctionParams]],
-    default_parser_class: Type[FunctionParams],
+    param_classes: Collection[type[FunctionParams]],
+    default_parser_class: type[FunctionParams],
 ) -> None:
     params = values.get(params_key, dict())
     if isinstance(params, FunctionParams):

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -3,6 +3,14 @@ CONTROL_OPERATOR_NAME = "control"
 INVERT_OPERATOR_NAME = "invert"
 REPEAT_OPERATOR_NAME = "iteration"
 POWER_OPERATOR_NAME = "power"
-COMPUTE_OPERATOR_NAME = "compute"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+
+All_BUILTINS_OPERATORS = {
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
+    UNCOMPUTE_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+}

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,4 +1,5 @@
-from typing import ClassVar, Dict, Optional, Sequence
+from collections.abc import Sequence
+from typing import ClassVar, Optional
 
 import pydantic
 
@@ -28,11 +29,11 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
     )
 
     BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "ClassicalFunctionDeclaration"]
+        dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
     FOREIGN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "ClassicalFunctionDeclaration"]
+        dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
     @property

classiq/interface/generator/functions/classical_type.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal, Union
 
 import pydantic
 from pydantic import ConfigDict
@@ -19,7 +19,7 @@ NamedSymbol = Union[IndexedBase, Symbol]
 
 
 class ClassicalType(HashableASTNode):
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
+    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
         return Symbol(name)
 
     model_config = ConfigDict(extra="forbid")
@@ -36,7 +36,7 @@ class Integer(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "int")
 
 
@@ -48,7 +48,7 @@ class Real(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "real")
 
 
@@ -57,7 +57,7 @@ class Bool(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "bool")
 
 
@@ -70,7 +70,7 @@ class ClassicalList(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
 
@@ -79,7 +79,7 @@ class StructMetaType(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
@@ -93,7 +93,7 @@ class ClassicalArray(ClassicalType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
 
@@ -106,7 +106,7 @@ class VQEResult(OpaqueHandle):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "vqe_result")
 
 
@@ -115,7 +115,7 @@ class Histogram(OpaqueHandle):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "histogram")
 
 
@@ -124,7 +124,7 @@ class Estimation(OpaqueHandle):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "estimation_result")
 
 
@@ -133,11 +133,11 @@ class IQAERes(OpaqueHandle):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
+def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
     return {
         param_name: param_type.as_symbolic(param_name)
         for param_name, param_type in symbols.items()

classiq/interface/generator/functions/concrete_types.py

@@ -1,7 +1,6 @@
-from typing import Union
+from typing import Annotated, Union
 
 from pydantic import Field
-from typing_extensions import Annotated
 
 from classiq.interface.generator.functions.classical_type import (
     Bool,

classiq/interface/generator/functions/function_declaration.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Sequence
+from collections.abc import Sequence
 
 from pydantic import ConfigDict
 

classiq/interface/generator/functions/qmod_python_interface.py

@@ -1,3 +1,4 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 QmodPyStruct = Mapping[str, Any]

classiq/interface/generator/functions/type_name.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Dict, Literal, Mapping, Optional
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
@@ -25,7 +26,7 @@ class TypeName(ClassicalType, QuantumType):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_kind(cls, values: Any) -> Dict[str, Any]:
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "struct_instance")
 
     def _update_size_in_bits_from_declaration(self) -> None:

classiq/interface/generator/generated_circuit_data.py

@@ -1,20 +1,20 @@
 import logging
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Literal, Optional, Union
 
 import pydantic
 from pydantic import ConfigDict
 from typing_extensions import TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
-from classiq.interface.ide.visual_model import OperationLevel, OperationParameter
 
 _logger = logging.getLogger(__name__)
 ParameterName = str
-IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
+IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
 
@@ -42,8 +42,8 @@ class QubitMapping(pydantic.BaseModel):
 class GeneratedRegister(pydantic.BaseModel):
     name: str
     role: RegisterRole
-    qubit_indexes_relative: List[int]
-    qubit_indexes_absolute: List[int]
+    qubit_indexes_relative: list[int]
+    qubit_indexes_absolute: list[int]
 
     def __len__(self) -> int:
         return self.qubit_indexes_relative.__len__()
@@ -55,13 +55,12 @@ class GeneratedRegister(pydantic.BaseModel):
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str
-    control_states: List[ControlState]
-    registers: List[GeneratedRegister] = list()
+    control_states: list[ControlState]
+    registers: list[GeneratedRegister] = list()
     depth: Optional[int] = pydantic.Field(default=None)
     width: Optional[int] = pydantic.Field(default=None)
-    released_auxiliary_qubits: List[int] = list()
-    dangling_inputs: Dict[str, GeneratedRegister] = dict()
-    dangling_outputs: Dict[str, GeneratedRegister] = dict()
+    dangling_inputs: dict[str, GeneratedRegister] = dict()
+    dangling_outputs: dict[str, GeneratedRegister] = dict()
 
     def __getitem__(self, key: Union[int, str]) -> GeneratedRegister:
         if isinstance(key, int):
@@ -88,7 +87,7 @@ class GeneratedFunction(pydantic.BaseModel):
 
 class GeneratedCircuitData(pydantic.BaseModel):
     width: int
-    circuit_parameters: List[ParameterName] = pydantic.Field(default_factory=list)
+    circuit_parameters: list[ParameterName] = pydantic.Field(default_factory=list)
     qubit_mapping: QubitMapping = pydantic.Field(default_factory=QubitMapping)
     execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
 
@@ -97,17 +96,29 @@ class GeneratedCircuitData(pydantic.BaseModel):
         return cls(width=0)
 
 
+class OperationLevel(StrEnum):
+    QMOD_FUNCTION_CALL = "QMOD_CALL"
+    QMOD_STATEMENT = "QMOD_STATEMENT"
+    ENGINE_FUNCTION_CALL = "ENGINE_CALL"
+    UNKNOWN = "UNKNOWN"
+
+
+class OperationParameter(pydantic.BaseModel):
+    label: str
+    value: Optional[str] = None
+
+
 class FunctionDebugInfoInterface(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
-    children: List["FunctionDebugInfoInterface"]
-    relative_qubits: Tuple[int, ...]
-    absolute_qubits: Optional[Tuple[int, ...]] = pydantic.Field(default=None)
+    children: list["FunctionDebugInfoInterface"]
+    relative_qubits: tuple[int, ...]
+    absolute_qubits: Optional[tuple[int, ...]] = pydantic.Field(default=None)
     is_basis_gate: Optional[bool] = pydantic.Field(default=None)
     is_inverse: bool = pydantic.Field(default=False)
     is_allocate_or_free: bool = pydantic.Field(default=False)
     level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
-    parameters: List[OperationParameter] = list()
-    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default={})
+    parameters: list[OperationParameter] = list()
+    port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
@@ -120,7 +131,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return self.generated_function.name
 
     @property
-    def registers(self) -> List[GeneratedRegister]:
+    def registers(self) -> list[GeneratedRegister]:
         if self.generated_function is None:
             return list()
         return self.generated_function.registers
@@ -132,15 +143,15 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return len(self.generated_function.control_states) > 0
 
     @property
-    def control_states(self) -> List[ControlState]:
+    def control_states(self) -> list[ControlState]:
         if self.generated_function is None:
             return list()
         return self.generated_function.control_states
 
     @staticmethod
     def create_parameters_from_dict(
-        parameters: Dict[str, str]
-    ) -> List[OperationParameter]:
+        parameters: dict[str, str]
+    ) -> list[OperationParameter]:
         return [
             OperationParameter(label=key, value=value)
             for key, value in parameters.items()
@@ -175,8 +186,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
 
 def _get_absolute_from_relative(
-    absolute_qubits: Tuple[int, ...], relative_qubits: Tuple[int, ...]
-) -> Tuple[int, ...]:
+    absolute_qubits: tuple[int, ...], relative_qubits: tuple[int, ...]
+) -> tuple[int, ...]:
     if max(relative_qubits) >= len(absolute_qubits):
         _logger.warning(
             "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",

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)