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

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,11 +1,9 @@
-from typing import Dict
-
 from classiq.interface.generator.types.builtin_enum_declarations import (
     FinanceFunctionType,
 )
 
 
-def get_finance_function_dict() -> Dict[str, "FinanceFunctionType"]:
+def get_finance_function_dict() -> dict[str, "FinanceFunctionType"]:
     return {
         "var": FinanceFunctionType.VAR,
         "expected shortfall": FinanceFunctionType.SHORTFALL,

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,6 +1,7 @@
 import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Mapping, Optional, Type
+from typing import Any, Optional
 
 from sympy import Expr
 from typing_extensions import get_args
@@ -19,7 +20,7 @@ from classiq.interface.generator.expressions.handle_identifier import HandleIden
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self, constant_type: Optional[Type] = None) -> bool:
+    def is_constant(self, constant_type: Optional[type] = None) -> bool:
         if self.value is None:
             return False
 
@@ -28,7 +29,7 @@ class EvaluatedExpression:
             get_args(RuntimeConstant) if constant_type is None else constant_type,
         )
 
-    def as_constant_type(self, constant_type: Type) -> Any:
+    def as_constant_type(self, constant_type: type) -> Any:
         if not self.is_constant():
             raise ClassiqValueError(
                 f"Invalid access to expression {self.value!r} as {constant_type}"

classiq/interface/generator/expressions/expression.py

@@ -1,6 +1,6 @@
 import ast
-import sys
-from typing import Any, Mapping, Optional, Type
+from collections.abc import Mapping
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
@@ -45,14 +45,13 @@ class Expression(HashableASTNode):
     @pydantic.field_validator("expr")
     @classmethod
     def format_expression(cls, expr: str) -> str:
-        if sys.version_info >= (3, 9):
-            expr = ast.unparse(ast.parse(expr))
+        expr = ast.unparse(ast.parse(expr))
         return expr
 
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 
-    def as_constant(self, constant_type: Type) -> Any:
+    def as_constant(self, constant_type: type) -> Any:
         return self.value.as_constant_type(constant_type)
 
     def to_int_value(self) -> int:

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Final, FrozenSet, Set
+from typing import Final
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -11,12 +11,12 @@ from classiq.interface.generator.function_params import NAME_REGEX
 
 SUPPORTED_VAR_NAMES_REG = NAME_REGEX
 
-SUPPORTED_FUNC_NAMES: Set[str] = (
+SUPPORTED_FUNC_NAMES: set[str] = (
     {"or", "and"}
     .union(DEFAULT_SUPPORTED_FUNC_NAMES)
     .union(set(SYMPY_SUPPORTED_EXPRESSIONS))
 )
 BOOLEAN_LITERALS = {"True", "False"}
-FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
 CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
-RESERVED_EXPRESSIONS: FrozenSet[str] = frozenset({"i"})
+RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Mapping, Union
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union
 
 from sympy import Integer
 

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -1,4 +1,5 @@
-from typing import Any, Mapping
+from collections.abc import Mapping
+from typing import Any
 
 from sympy import Symbol
 

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding

classiq/interface/generator/expressions/qmod_struct_instance.py

@@ -1,5 +1,6 @@
 import types
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -1,7 +1,5 @@
-from typing import List
-
-BASIC_ARITHMETIC_OPERATORS: List[str] = ["+", "-", "*", "/", "%"]
-MATHEMATICAL_FUNCTIONS: List[str] = [
+BASIC_ARITHMETIC_OPERATORS: list[str] = ["+", "-", "*", "/", "%"]
+MATHEMATICAL_FUNCTIONS: list[str] = [
     "sin",
     "cos",
     "tan",
@@ -36,7 +34,7 @@ MATHEMATICAL_FUNCTIONS: List[str] = [
     "Min",
     "mod_inverse",
 ]
-SPECIAL_FUNCTIONS: List[str] = [
+SPECIAL_FUNCTIONS: list[str] = [
     "erf",
     "erfc",
     "gamma",
@@ -57,8 +55,8 @@ SPECIAL_FUNCTIONS: List[str] = [
     "euler",
     "catalan",
 ]
-PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-NUMERIC_CONSTANTS: List[str] = [
+PIECEWISE_FUNCTIONS: list[str] = ["Piecewise", "Heaviside"]
+NUMERIC_CONSTANTS: list[str] = [
     "pi",
     "E",
     "I",
@@ -66,11 +64,11 @@ NUMERIC_CONSTANTS: List[str] = [
     "EulerGamma",
     "Catalan",
 ]
-BOOLEAN_CONSTANTS: List[str] = ["true", "false"]
-CONSTANTS: List[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
+BOOLEAN_CONSTANTS: list[str] = ["true", "false"]
+CONSTANTS: list[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
 
-DATA_TYPES: List[str] = ["Matrix"]
-LOGIC_OPERATORS: List[str] = [
+DATA_TYPES: list[str] = ["Matrix"]
+LOGIC_OPERATORS: list[str] = [
     "And",
     "Or",
     "Not",
@@ -80,9 +78,9 @@ LOGIC_OPERATORS: List[str] = [
     "Nand",
     "Nor",
 ]
-RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
+RELATIONAL_OPERATORS: list[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
 
-SYMPY_SUPPORTED_EXPRESSIONS: List[str] = (
+SYMPY_SUPPORTED_EXPRESSIONS: list[str] = (
     BASIC_ARITHMETIC_OPERATORS
     + MATHEMATICAL_FUNCTIONS
     + SPECIAL_FUNCTIONS

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/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,13 @@ 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()
+    released_auxiliary_qubits: list[int] = list()
+    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 +88,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 +97,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 +132,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 +144,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 +187,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)",