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

classiq/interface/generator/qsvm.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Union
+from typing import Literal, Optional, Union
 
 import numpy as np
 import pydantic
@@ -37,13 +37,13 @@ class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
     reps: int = 2
     entanglement: QSVMFeatureMapEntanglement = QSVMFeatureMapEntanglement.LINEAR
     alpha: float = 2.0
-    paulis: List[str] = ["Z", "ZZ"]
+    paulis: list[str] = ["Z", "ZZ"]
     parameter_prefix: str = "x"
     name: str = "PauliFeatureMap"
 
     @pydantic.field_validator("paulis", mode="before")
     @classmethod
-    def set_paulis(cls, paulis: List[str]) -> List[str]:
+    def set_paulis(cls, paulis: list[str]) -> list[str]:
         # iterate every letter in every string in the list of paulis
         for s in paulis:
             if not all(map(VALID_PAULI_LETTERS.__contains__, s.upper())):

classiq/interface/generator/quantum_function_call.py

@@ -6,16 +6,11 @@ import random
 import re
 import string
 from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from re import Match
 from typing import (
     Any,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Match,
     Optional,
-    Sequence,
-    Tuple,
     Union,
 )
 from uuid import UUID, uuid4
@@ -64,7 +59,7 @@ LEGAL_SLICING = rf"(\-?\d+)?({SEPARATOR}(\-?\d+)?)?({SEPARATOR}(\-?\d+)?)?"
 
 _ALPHANUM_CHARACTERS = string.ascii_letters + string.digits
 
-RegNameAndSlice = Tuple[str, slice]
+RegNameAndSlice = tuple[str, slice]
 
 ZERO_INDICATOR = "0"
 INVERSE_SUFFIX = "_qinverse"
@@ -86,7 +81,7 @@ SUFFIX_RANDOMIZER = random.Random()  # noqa: S311
 
 def split_wire_pair_to_wires(
     inout: WirePair,
-) -> Tuple[WireName, WireName]:
+) -> tuple[WireName, WireName]:
     return inout.in_wire, inout.out_wire
 
 
@@ -98,7 +93,7 @@ def randomize_suffix(suffix_len: int = DEFAULT_SUFFIX_LEN) -> str:
 
 def get_non_zero_wires(
     wires: Iterable[WireName],
-) -> List[WireName]:
+) -> list[WireName]:
     return [wire for wire in wires if wire != ZERO_INDICATOR]
 
 
@@ -122,7 +117,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
     release_by_inverse: bool = pydantic.Field(
         default=False, description="Release zero inputs in inverse call."
     )
-    control_states: List[ControlState] = pydantic.Field(
+    control_states: list[ControlState] = pydantic.Field(
         default_factory=list,
         description="Call the controlled function with the given controlled states.",
     )
@@ -166,14 +161,14 @@ class SynthesisQuantumFunctionCall(BaseModel):
         return hash(self.name)
 
     @property
-    def non_zero_input_wires(self) -> List[WireName]:
+    def non_zero_input_wires(self) -> list[WireName]:
         in_out_input_wires = [
             split_wire_pair_to_wires(inout)[0] for inout in self.inouts.values()
         ]
         return get_non_zero_wires(self.inputs_dict.values()) + in_out_input_wires
 
     @property
-    def non_zero_output_wires(self) -> List[WireName]:
+    def non_zero_output_wires(self) -> list[WireName]:
         in_out_output_wires = [
             split_wire_pair_to_wires(inout)[1] for inout in self.inouts.values()
         ]
@@ -246,7 +241,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
     @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 (
             isinstance(values, dict)
             and isinstance(values.get("unitary_params"), CustomFunction)
@@ -259,7 +254,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _parse_function_params(cls, values: Any) -> Dict[str, Any]:
+    def _parse_function_params(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             f_params.parse_function_params_values(
                 values=values,
@@ -279,7 +274,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         params: f_params.FunctionParams,
         inputs: WireDict,
         is_inverse: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> None:
         (
@@ -317,8 +312,8 @@ class SynthesisQuantumFunctionCall(BaseModel):
     @pydantic.field_validator("control_states")
     @classmethod
     def _validate_control_states(
-        cls, control_states: List[ControlState], info: ValidationInfo
-    ) -> List[ControlState]:
+        cls, control_states: list[ControlState], info: ValidationInfo
+    ) -> list[ControlState]:
         control_names = [ctrl_state.name for ctrl_state in control_states]
         function_params = info.data.get("function_params")
         strict_zero_ios = info.data.get("strict_zero_ios")
@@ -349,10 +344,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
         inputs: IOType,
         fp: FunctionParams,
         strict_zero_ios: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
     ) -> None:
         name_slice_pairs = [parse_io_slicing(input) for input in inputs]
-        slices_dict: Dict[str, List[slice]] = defaultdict(list)
+        slices_dict: dict[str, list[slice]] = defaultdict(list)
         for name, slice in name_slice_pairs:
             slices_dict[name].append(slice)
 
@@ -374,7 +369,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 raise ClassiqValueError(BAD_INPUT_SLICING_MSG)
 
     @staticmethod
-    def _register_validate_slices(slices: List[slice], reg_width: int) -> bool:
+    def _register_validate_slices(slices: list[slice], reg_width: int) -> bool:
         widths_separated = [len(range(reg_width)[reg_slice]) for reg_slice in slices]
         # examples: slice(0), slice(5,None) when width <= 5, slice(5,3)
         empty_slices = 0 in widths_separated
@@ -399,7 +394,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         params: Optional[FunctionParams] = info.data.get("function_params")
         is_inverse: bool = info.data.get("is_inverse", False)
         strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
-        control_states: List[ControlState] = info.data.get("control_states", list())
+        control_states: list[ControlState] = info.data.get("control_states", list())
         if params is None:
             return dict()
         if isinstance(params, CustomFunction):
@@ -440,7 +435,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         params: f_params.FunctionParams,
         outputs: WireDict,
         is_inverse: bool,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> None:
         (
@@ -549,15 +544,15 @@ class SynthesisQuantumFunctionCall(BaseModel):
         expressions: Iterable[str],
         params: f_params.FunctionParams,
         io: f_params.PortDirection,
-        control_states: List[ControlState],
+        control_states: list[ControlState],
         strict_zero_ios: bool,
-    ) -> Tuple[List[str], List[str], List[str]]:
+    ) -> tuple[list[str], list[str], list[str]]:
         expression_matches: Iterable[Optional[Match]] = map(
             functools.partial(re.fullmatch, IO_REGEX), expressions
         )
 
-        valid_matches: List[Match] = []
-        invalid_expressions: List[str] = []
+        valid_matches: list[Match] = []
+        invalid_expressions: list[str] = []
         for expression, expression_match in zip(expressions, expression_matches):
             (
                 invalid_expressions.append(expression)
@@ -565,8 +560,8 @@ class SynthesisQuantumFunctionCall(BaseModel):
                 else valid_matches.append(expression_match)
             )
 
-        invalid_slicings: List[str] = []
-        invalid_names: List[str] = []
+        invalid_slicings: list[str] = []
+        invalid_names: list[str] = []
         valid_names = frozenset(
             params.inputs_full(strict_zero_ios)
             if io == PortDirection.Input

classiq/interface/generator/quantum_program.py

@@ -1,7 +1,7 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -31,17 +31,17 @@ from classiq.interface.generator.synthesis_metadata.synthesis_duration import (
     SynthesisStepDurations,
 )
 from classiq.interface.helpers.versioned_model import VersionedModel
-from classiq.interface.ide.ide_data import CircuitMetrics
+from classiq.interface.ide.visual_model import CircuitMetrics
 
 RegisterName: TypeAlias = str
-InitialConditions: TypeAlias = Dict[RegisterName, int]
+InitialConditions: TypeAlias = dict[RegisterName, int]
 
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
-    count_ops: Dict[str, int]
-    logical_to_physical_input_qubit_map: List[int]
-    logical_to_physical_output_qubit_map: List[int]
+    count_ops: dict[str, int]
+    logical_to_physical_input_qubit_map: list[int]
+    logical_to_physical_output_qubit_map: list[int]
 
     def get_circuit_metrics(self) -> CircuitMetrics:
         return CircuitMetrics(depth=self.depth, count_ops=self.count_ops)
@@ -65,7 +65,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     transpiled_circuit: Optional[TranspiledCircuitData] = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: Optional[SynthesisStepDurations] = pydantic.Field(default=None)
-    debug_info: Optional[List[FunctionDebugInfoInterface]] = pydantic.Field(
+    debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
         default=None
     )
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
@@ -123,7 +123,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             synthesis_execution_data=self.data.execution_data,
         )
 
-    def _get_initialization_qubits(self, name: str) -> Tuple[int, ...]:
+    def _get_initialization_qubits(self, name: str) -> tuple[int, ...]:
         qubits = self.data.qubit_mapping.logical_inputs.get(name)
         if qubits is None:
             raise ClassiqStateInitializationError(
@@ -133,7 +133,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def get_registers_initialization(
         self, initial_values: InitialConditions
-    ) -> Dict[RegisterName, RegisterInitialization]:
+    ) -> dict[RegisterName, RegisterInitialization]:
         return {
             name: RegisterInitialization(
                 name=name,

classiq/interface/generator/register_role.py

@@ -1,5 +1,3 @@
-from typing import Set
-
 from classiq.interface.enum_utils import StrEnum
 
 
@@ -13,7 +11,7 @@ class RegisterRole(StrEnum):
     EXPLICIT_ZERO_INPUT = "explicit_zero_input"
 
     @staticmethod
-    def output_roles(include_garbage: bool = False) -> Set["RegisterRole"]:
+    def output_roles(include_garbage: bool = False) -> set["RegisterRole"]:
         roles = {
             RegisterRole.OUTPUT,
             RegisterRole.ZERO_OUTPUT,
@@ -24,7 +22,7 @@ class RegisterRole(StrEnum):
         return roles
 
     @staticmethod
-    def input_roles() -> Set["RegisterRole"]:
+    def input_roles() -> set["RegisterRole"]:
         return {
             RegisterRole.INPUT,
             RegisterRole.ZERO_INPUT,

classiq/interface/generator/slice_parsing_utils.py

@@ -1,5 +1,6 @@
 import re
-from typing import Match, Optional, Tuple
+from re import Match
+from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import NAME_REGEX
@@ -11,12 +12,12 @@ SLICING_CHARS = rf"[0-9\-{SEPARATOR}]+"
 IO_REGEX = rf"(?P<{NAME}>{NAME_REGEX})(\[(?P<{SLICING}>{SLICING_CHARS})\])?"
 
 
-def parse_io_slicing(io_str: str) -> Tuple[str, slice]:
+def parse_io_slicing(io_str: str) -> tuple[str, slice]:
     name, slicing = separate_name_and_slice(io_str)
     return name, get_slice(slicing)
 
 
-def separate_name_and_slice(io_str: str) -> Tuple[str, Optional[str]]:
+def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
     match: Optional[Match] = re.fullmatch(IO_REGEX, io_str)
     if match is None:
         raise AssertionError("Input/output name validation error")

classiq/interface/generator/standard_gates/standard_gates.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Literal, Optional
+from typing import Any, Literal, Optional
 
 import pydantic
 
@@ -13,7 +13,7 @@ To add new standard gates, refer to the following guide
 https://docs.google.com/document/d/1Nt9frxnPkSn8swNpOQ983E95eaEiDWaiuWAKglGtUAA/edit#heading=h.e9g9309bzkxt
 """
 
-_POSSIBLE_PARAMETERS: List[str] = ["theta", "phi", "lam"]
+_POSSIBLE_PARAMETERS: list[str] = ["theta", "phi", "lam"]
 DEFAULT_STANDARD_GATE_ARG_NAME: str = "TARGET"
 
 
@@ -39,7 +39,7 @@ class _StandardGate(FunctionParams, metaclass=MyMetaAngledClassModel):  # type:
         return self._num_target_qubits
 
     def __init_subclass__(
-        cls, angles: Optional[List[str]] = None, **kwargs: Any
+        cls, angles: Optional[list[str]] = None, **kwargs: Any
     ) -> None:
         super().__init_subclass__(**kwargs)
 

classiq/interface/generator/state_preparation/bell_state_preparation.py

@@ -1,4 +1,4 @@
-from typing import FrozenSet, Literal
+from typing import Literal
 
 import pydantic
 
@@ -7,8 +7,8 @@ from classiq.interface.generator.state_preparation.state_preparation_abc import
 )
 
 BellStateName = Literal["psi+", "psi-", "phi+", "phi-"]
-_ALIGNED_STATES: FrozenSet[BellStateName] = frozenset({"phi+", "phi-"})
-_SIGNED_STATES: FrozenSet[BellStateName] = frozenset({"psi-", "phi-"})
+_ALIGNED_STATES: frozenset[BellStateName] = frozenset({"phi+", "phi-"})
+_SIGNED_STATES: frozenset[BellStateName] = frozenset({"psi-", "phi-"})
 
 
 class BellStatePreparation(StatePreparationABC):

classiq/interface/generator/state_preparation/distributions.py

@@ -1,4 +1,5 @@
-from typing import Collection, Sequence, Tuple, Union
+from collections.abc import Collection, Sequence
+from typing import Union
 
 import pydantic
 from numpy.typing import ArrayLike
@@ -11,12 +12,12 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class PMF(pydantic.BaseModel):
-    pmf: Tuple[PydanticProbabilityFloat, ...]
+    pmf: tuple[PydanticProbabilityFloat, ...]
 
     @pydantic.field_validator("pmf")
     @classmethod
     def _validate_pmf(
-        cls, pmf: Tuple[PydanticProbabilityFloat, ...]
+        cls, pmf: tuple[PydanticProbabilityFloat, ...]
     ) -> Sequence[PydanticProbabilityFloat]:
         return validate_probabilities(cls, pmf)
 
@@ -30,7 +31,7 @@ class GaussianMoments(pydantic.BaseModel):
 
 
 class GaussianMixture(pydantic.BaseModel):
-    gaussian_moment_list: Tuple[GaussianMoments, ...]
+    gaussian_moment_list: tuple[GaussianMoments, ...]
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="Number of qubits for the provided state."
     )
@@ -39,7 +40,7 @@ class GaussianMixture(pydantic.BaseModel):
 
 Probabilities = Union[PMF, GaussianMixture]
 FlexibleProbabilities = Union[Probabilities, ArrayLike, dict, Collection[float]]
-Amplitudes = Tuple[float, ...]
+Amplitudes = tuple[float, ...]
 FlexibleAmplitudes = Union[ArrayLike, Collection[float]]
 Distribution = Union[Amplitudes, Probabilities]
 

classiq/interface/generator/state_preparation/metrics.py

@@ -1,16 +1,14 @@
-from typing import FrozenSet
-
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.preferences.optimization import (
     StatePrepOptimizationMethod,
 )
 
-_AMPLITUDE_SUPPORTING_METRICS: FrozenSet = frozenset(
+_AMPLITUDE_SUPPORTING_METRICS: frozenset = frozenset(
     {"L2", "L1", "MAX_PROBABILITY", "TOTAL_VARIATION"}
 )
 
-_ZERO_DIVERGENT_METRICS: FrozenSet = frozenset({"KL", "BHATTACHARYYA"})
+_ZERO_DIVERGENT_METRICS: frozenset = frozenset({"KL", "BHATTACHARYYA"})
 
 
 class Metrics(StrEnum):

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import numpy as np
 import pydantic
@@ -36,7 +36,7 @@ class StatePreparation(StatePreparationABC):
         default=None,
         validate_default=True,
     )
-    error_metric: Dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
+    error_metric: dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
         default_factory=lambda: {
             Metrics.L2: NonNegativeFloatRange(lower_bound=0, upper_bound=1e-4)
         }
@@ -80,8 +80,8 @@ class StatePreparation(StatePreparationABC):
     @pydantic.field_validator("error_metric", mode="before")
     @classmethod
     def _validate_error_metric(
-        cls, error_metric: Dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
-    ) -> Dict[Metrics, NonNegativeFloatRange]:
+        cls, error_metric: dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
+    ) -> dict[Metrics, NonNegativeFloatRange]:
         if not info.data.get("amplitudes"):
             return error_metric
         unsupported_metrics = {

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Set
+from typing import Optional
 
 import pydantic
 import sympy
@@ -24,14 +24,14 @@ class FunctionExecutionData(pydantic.BaseModel):
 
 
 class ExecutionData(pydantic.BaseModel):
-    function_execution: Dict[str, FunctionExecutionData] = pydantic.Field(
+    function_execution: dict[str, FunctionExecutionData] = pydantic.Field(
         default_factory=dict
     )
 
     @property
     def execution_parameters(
         self,
-    ) -> Set[PydanticExecutionParameter]:
+    ) -> set[PydanticExecutionParameter]:
         return {
             function_execution_data.power_var
             for function_execution_data in self.function_execution.values()

classiq/interface/generator/transpiler_basis_gates.py

@@ -1,10 +1,10 @@
-from typing import TYPE_CHECKING, FrozenSet, Optional
+from typing import TYPE_CHECKING, Optional
 
 from typing_extensions import TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 
-BasisGates: TypeAlias = FrozenSet[str]
+BasisGates: TypeAlias = frozenset[str]
 
 SINGLE_QUBIT_GATES: BasisGates = frozenset(
     (

classiq/interface/generator/types/enum_declaration.py

@@ -1,6 +1,5 @@
 from collections import Counter
 from enum import Enum, EnumMeta, IntEnum
-from typing import Dict
 
 import pydantic
 
@@ -11,14 +10,14 @@ from classiq.interface.exceptions import ClassiqValueError
 class EnumDeclaration(HashableASTNode):
     name: str
 
-    members: Dict[str, int] = pydantic.Field(
+    members: dict[str, int] = pydantic.Field(
         default_factory=dict,
         description="Dictionary of member names and their values",
     )
 
     @pydantic.field_validator("members")
     @classmethod
-    def _validate_members(cls, members: Dict[str, int]) -> Dict[str, int]:
+    def _validate_members(cls, members: dict[str, int]) -> dict[str, int]:
         underscore_members = [
             member for member in members.keys() if member.startswith("_")
         ]

classiq/interface/generator/types/qstruct_declaration.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
 
 import pydantic
 

classiq/interface/generator/types/struct_declaration.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 import pydantic
 
@@ -10,7 +11,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 class StructDeclaration(HashableASTNode):
     name: str
 
-    variables: Dict[str, ConcreteClassicalType] = pydantic.Field(
+    variables: dict[str, ConcreteClassicalType] = pydantic.Field(
         default_factory=dict,
         description="Dictionary of variable names and their classical types",
     )

classiq/interface/generator/ucc.py

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

classiq/interface/generator/unitary_gate.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import Union
 
 import numpy as np
 import pydantic
@@ -8,7 +8,7 @@ from classiq.interface.generator import complex_type, function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 DataNumber = Union[complex_type.Complex, float, int]
-DataArray = List[List[DataNumber]]
+DataArray = list[list[DataNumber]]
 
 UNITARY_GATE_INPUT: str = "TARGET"
 UNITARY_GATE_OUTPUT: str = "TARGET"

classiq/interface/generator/user_defined_function_params.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 import pydantic
 from pydantic import ConfigDict

classiq/interface/generator/validations/flow_graph.py

@@ -1,7 +1,8 @@
 from collections import Counter, defaultdict
+from collections.abc import Collection, Iterable, Mapping
 from dataclasses import dataclass
 from itertools import chain
-from typing import Collection, Iterable, List, Mapping, Optional, TypeVar
+from typing import Optional, TypeVar
 
 import networkx as nx
 
@@ -152,7 +153,7 @@ def validate_legal_wiring(
     raise ClassiqValueError(_join_errors(error_messages))
 
 
-def _join_errors(error_messages: List[str]) -> str:
+def _join_errors(error_messages: list[str]) -> str:
     if not error_messages:
         error_messages.append(f"{UNKNOWN_ERROR_MSG}")
 
@@ -162,7 +163,7 @@ def _join_errors(error_messages: List[str]) -> str:
 T = TypeVar("T")
 
 
-def _recurring_names(name_list: List[T]) -> Iterable[T]:
+def _recurring_names(name_list: list[T]) -> Iterable[T]:
     name_counter = Counter(name_list)
     return (name for name, appearances in name_counter.items() if appearances > 1)
 
@@ -187,11 +188,11 @@ def validate_acyclic_logic_flow(
 
 
 def validate_acyclicity_and_topologically_sort_logic_flow(
-    body: List[SynthesisQuantumFunctionCall],
+    body: list[SynthesisQuantumFunctionCall],
     *,
     flow_input_names: Collection[str],
     flow_output_names: Collection[str],
-) -> List[SynthesisQuantumFunctionCall]:
+) -> list[SynthesisQuantumFunctionCall]:
     graph = validate_acyclic_logic_flow(
         body=body,
         flow_input_names=flow_input_names,

classiq/interface/generator/validations/validator_functions.py

@@ -1,4 +1,5 @@
-from typing import Iterable, List, Sequence, Sized, Tuple, TypeVar
+from collections.abc import Iterable, Sequence, Sized
+from typing import TypeVar
 
 import numpy as np
 
@@ -9,7 +10,7 @@ NOT_SUM_TO_ONE_ERROR = "Probabilities do not sum to 1"
 
 SUM_TO_ONE_SENSITIVITY = 8
 
-Amplitude = TypeVar("Amplitude", Tuple[float, ...], List[complex])
+Amplitude = TypeVar("Amplitude", tuple[float, ...], list[complex])
 
 
 def _is_power_of_two(vector: Sized) -> bool: