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

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

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