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

classiq/interface/ide/ide_data.py

@@ -1,13 +1,14 @@
 from enum import IntEnum
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import pydantic
 
 from classiq.interface.generator.generated_circuit_data import GeneratedFunction
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.ide.visual_model import CircuitMetrics
 
-GateCount = Dict[str, int]
+GateCount = dict[str, int]
 Depth = int
 
 
@@ -51,17 +52,17 @@ class ConditionalRender(IntEnum):
 class IDEDataOperation(pydantic.BaseModel):
     gate: str
     displayName: str
-    children: List["IDEDataOperation"]
+    children: list["IDEDataOperation"]
     depth: Depth
     width: int
     gate_count: GateCount
     _qubits: list = pydantic.PrivateAttr()  # list[Qubit]
 
     displayArgs: str = ""
-    targets: Union[List[IDEQubitDef], List[IDEClassicalBitDef]] = pydantic.Field(
+    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(
         default_factory=list
     )
-    controls: List[IDEQubitDef] = list()
+    controls: list[IDEQubitDef] = list()
     dataAttributes: DataAttributes = pydantic.Field(default_factory=DataAttributes)
     isControlled: bool = False
     isMeasurement: bool = False
@@ -81,7 +82,7 @@ class IDEDataProperties(pydantic.BaseModel):
 
 
 class RegisterData(pydantic.BaseModel):
-    segmentIds: List[str]
+    segmentIds: list[str]
     properties: IDEDataProperties
     registerId: str
 
@@ -91,16 +92,11 @@ class InterfaceSegmentData(pydantic.BaseModel):
     properties: IDEDataProperties
 
 
-class CircuitMetrics(pydantic.BaseModel):
-    depth: int
-    count_ops: Dict[str, int]
-
-
 class IDEData(VersionedModel):
-    qubits: List[IDEDataQubit]
-    operations: List[IDEDataOperation]
-    register_data: List[RegisterData]
-    segment_data: List[InterfaceSegmentData]
+    qubits: list[IDEDataQubit]
+    operations: list[IDEDataOperation]
+    register_data: list[RegisterData]
+    segment_data: list[InterfaceSegmentData]
     circuit_metrics: Optional[CircuitMetrics]
     hardware_data: SynthesisHardwareData
     creation_time: str

classiq/interface/ide/visual_model.py

@@ -1,20 +1,17 @@
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pydantic
 from pydantic import ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.generated_circuit_data import (
+    OperationLevel,
+    OperationParameter,
+)
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
-class OperationLevel(StrEnum):
-    QMOD_FUNCTION_CALL = "QMOD_CALL"
-    QMOD_STATEMENT = "QMOD_STATEMENT"
-    ENGINE_FUNCTION_CALL = "ENGINE_CALL"
-    UNKNOWN = "UNKNOWN"
-
-
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
     ALLOCATE = "ALLOCATE"
@@ -26,22 +23,23 @@ class OperationType(StrEnum):
 class OperationData(pydantic.BaseModel):
     approximated_depth: Optional[int] = None
     width: int
-    gate_count: Dict[str, int] = pydantic.Field(default_factory=dict)
+    gate_count: dict[str, int] = pydantic.Field(default_factory=dict)
 
 
-class ProgramData(pydantic.BaseModel):
-    hardware_data: SynthesisHardwareData
+class CircuitMetrics(pydantic.BaseModel):
+    depth: int
+    count_ops: dict[str, int]
 
 
-class OperationParameter(pydantic.BaseModel):
-    label: str
-    value: Optional[str] = None
+class ProgramData(pydantic.BaseModel):
+    hardware_data: SynthesisHardwareData
+    circuit_metrics: CircuitMetrics
 
 
 class OperationLink(pydantic.BaseModel):
     label: str
     inner_label: Optional[str] = None
-    qubits: Tuple[int, ...]
+    qubits: tuple[int, ...]
     type: str
 
     model_config = ConfigDict(frozen=True)
@@ -56,8 +54,8 @@ class OperationLink(pydantic.BaseModel):
 
 
 class OperationLinks(pydantic.BaseModel):
-    inputs: List[OperationLink]
-    outputs: List[OperationLink]
+    inputs: list[OperationLink]
+    outputs: list[OperationLink]
 
     @property
     def input_width(self) -> int:
@@ -106,13 +104,13 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
-    children: List["Operation"]
+    children: list["Operation"]
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
-    control_qubits: Tuple[int, ...] = pydantic.Field(default_factory=tuple)
-    auxiliary_qubits: Tuple[int, ...]
-    target_qubits: Tuple[int, ...]
-    parameters: List[OperationParameter] = pydantic.Field(default_factory=list)
+    control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
+    auxiliary_qubits: tuple[int, ...]
+    target_qubits: tuple[int, ...]
+    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
         description="Identifies unique operations that are visualized differently"

classiq/interface/jobs.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generic, Optional, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel
@@ -8,7 +8,7 @@ from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError
 from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
-JSONObject = Dict[str, Any]
+JSONObject = dict[str, Any]
 T = TypeVar("T", bound=Union[pydantic.BaseModel, JSONObject])
 AUTH_HEADER = "Classiq-BE-Auth"
 INVALID_RESPONSE_ERROR_MSG = "Invalid response from Classiq API"

classiq/interface/model/bind_operation.py

@@ -1,4 +1,5 @@
-from typing import List, Literal, Mapping, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
@@ -13,8 +14,8 @@ BIND_OUTPUT_NAME = "bind_output"
 class BindOperation(QuantumOperation):
     kind: Literal["BindOperation"]
 
-    in_handles: List[ConcreteHandleBinding]
-    out_handles: List[ConcreteHandleBinding]
+    in_handles: list[ConcreteHandleBinding]
+    out_handles: list[ConcreteHandleBinding]
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
@@ -51,7 +52,7 @@ class BindOperation(QuantumOperation):
 
     @pydantic.field_validator("in_handles", "out_handles")
     @classmethod
-    def validate_handle(cls, handles: List[HandleBinding]) -> List[HandleBinding]:
+    def validate_handle(cls, handles: list[HandleBinding]) -> list[HandleBinding]:
         for handle in handles:
             if not handle.is_bindable():
                 raise ClassiqValueError(f"Cannot bind '{handle}'")

classiq/interface/model/classical_parameter_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal
+from typing import Any, Literal
 
 import pydantic
 
@@ -14,7 +14,7 @@ class AnonClassicalParameterDeclaration(Parameter):
 
     @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", "ClassicalParameterDeclaration"
         )

classiq/interface/model/handle_binding.py

@@ -1,5 +1,6 @@
+from collections.abc import Sequence
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, Sequence, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -51,7 +52,7 @@ class NestedHandleBinding(HandleBinding):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_name(cls, values: Any) -> Dict[str, Any]:
+    def _set_name(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             orig = values
             while "base_handle" in values:

classiq/interface/model/inplace_binary_operation.py

@@ -1,4 +1,5 @@
-from typing import Literal, Mapping, Sequence, Union
+from collections.abc import Mapping, Sequence
+from typing import Literal, Union
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.expressions.expression import Expression

classiq/interface/model/model.py

@@ -1,5 +1,6 @@
 from collections import Counter
-from typing import Any, List, Literal, Mapping, NewType
+from collections.abc import Mapping
+from typing import Any, Literal, NewType
 
 import pydantic
 
@@ -58,23 +59,23 @@ class Model(VersionedModel, ASTNode):
     kind: Literal["user"] = pydantic.Field(default=USER_MODEL_MARKER)
 
     # Must be validated before logic_flow
-    functions: List[NativeFunctionDefinition] = pydantic.Field(
+    functions: list[NativeFunctionDefinition] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom type library.",
         validate_default=True,
     )
 
-    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",
     )
@@ -83,7 +84,7 @@ class Model(VersionedModel, ASTNode):
         description="The classical execution code of the model", default=""
     )
 
-    constants: List[Constant] = pydantic.Field(
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -133,8 +134,8 @@ class Model(VersionedModel, ASTNode):
     @pydantic.field_validator("functions")
     @classmethod
     def _add_empty_main(
-        cls, functions: List[NativeFunctionDefinition]
-    ) -> List[NativeFunctionDefinition]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             functions.append(_create_empty_main_function())
@@ -146,8 +147,8 @@ class Model(VersionedModel, ASTNode):
     @pydantic.field_validator("functions")
     @classmethod
     def _validate_entry_point(
-        cls, functions: List[NativeFunctionDefinition]
-    ) -> List[NativeFunctionDefinition]:
+        cls, functions: list[NativeFunctionDefinition]
+    ) -> list[NativeFunctionDefinition]:
         function_dict = nameables_to_dict(functions)
         if MAIN_FUNCTION_NAME not in function_dict:
             raise ClassiqValueError("The model must contain a `main` function")
@@ -161,7 +162,7 @@ class Model(VersionedModel, ASTNode):
 
     @pydantic.field_validator("constants")
     @classmethod
-    def _validate_constants(cls, constants: List[Constant]) -> List[Constant]:
+    def _validate_constants(cls, constants: list[Constant]) -> list[Constant]:
         constant_definition_counts = Counter(
             [constant.name for constant in constants]
         ).items()

classiq/interface/model/port_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Literal
+from typing import Any, Literal
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -19,7 +19,7 @@ class AnonPortDeclaration(Parameter):
 
     @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", "PortDeclaration")
 
     @pydantic.field_validator("direction", mode="before")

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,4 +1,5 @@
-from typing import Dict, Literal, Mapping, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
@@ -61,7 +62,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         if len(var_types) != 1:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,4 +1,5 @@
-from typing import Dict, Literal, Mapping, Optional, Sequence
+from collections.abc import Mapping, Sequence
+from typing import Literal, Optional
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -60,7 +61,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -1,5 +1,6 @@
 import abc
-from typing import Dict, List, Mapping, Optional
+from collections.abc import Mapping
+from typing import Optional
 
 import pydantic
 
@@ -15,27 +16,27 @@ from classiq.interface.model.quantum_type import QuantumType
 
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
-    _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
+    _var_handles: list[HandleBinding] = pydantic.PrivateAttr(
         default_factory=list,
     )
-    _var_types: Dict[str, QuantumType] = pydantic.PrivateAttr(
+    _var_types: dict[str, QuantumType] = pydantic.PrivateAttr(
         default_factory=dict,
     )
 
     @property
-    def var_handles(self) -> List[HandleBinding]:
+    def var_handles(self) -> list[HandleBinding]:
         return self._var_handles
 
-    def set_var_handles(self, var_handles: List[HandleBinding]) -> None:
+    def set_var_handles(self, var_handles: list[HandleBinding]) -> None:
         self._var_handles = var_handles
 
     @property
-    def var_types(self) -> Dict[str, QuantumType]:
+    def var_types(self) -> dict[str, QuantumType]:
         return self._var_types
 
     def initialize_var_types(
         self,
-        var_types: Dict[str, QuantumType],
+        var_types: dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
         assert len(var_types) == len(self.var_handles) or len(self.var_handles) == 0

classiq/interface/model/quantum_function_call.py

@@ -1,12 +1,7 @@
+from collections.abc import Iterable, Mapping, Sequence
 from typing import (
-    Dict,
-    Iterable,
-    List,
     Literal,
-    Mapping,
     Optional,
-    Sequence,
-    Tuple,
     Union,
 )
 
@@ -47,7 +42,7 @@ class QuantumFunctionCall(QuantumOperation):
     function: Union[str, OperandIdentifier] = pydantic.Field(
         description="The function that is called"
     )
-    positional_args: List[ArgValue] = pydantic.Field(default_factory=list)
+    positional_args: list[ArgValue] = pydantic.Field(default_factory=list)
 
     _func_decl: Optional[QuantumFunctionDeclaration] = pydantic.PrivateAttr(
         default=None
@@ -151,17 +146,17 @@ class QuantumFunctionCall(QuantumOperation):
         ]
 
     @property
-    def params(self) -> List[Expression]:
+    def params(self) -> list[Expression]:
         return [
             param for param in self.positional_args if isinstance(param, Expression)
         ]
 
     @property
-    def params_dict(self) -> Dict[str, Expression]:
+    def params_dict(self) -> dict[str, Expression]:
         return dict(zip(self.func_decl.param_names, self.params))
 
     @property
-    def operands(self) -> List["QuantumOperand"]:
+    def operands(self) -> list["QuantumOperand"]:
         return [
             param
             for param in self.positional_args
@@ -169,14 +164,14 @@ class QuantumFunctionCall(QuantumOperation):
         ]
 
     @property
-    def ports(self) -> List[HandleBinding]:
+    def ports(self) -> list[HandleBinding]:
         return [
             param for param in self.positional_args if isinstance(param, HandleBinding)
         ]
 
     def _get_handles_by_direction(
         self, direction: PortDeclarationDirection
-    ) -> List[Tuple[int, AnonPortDeclaration, HandleBinding]]:
+    ) -> list[tuple[int, AnonPortDeclaration, HandleBinding]]:
         return [
             (idx, port_decl, handle)
             for idx, port_decl, handle in self._get_handles_with_declarations()
@@ -185,7 +180,7 @@ class QuantumFunctionCall(QuantumOperation):
 
     def _get_pos_port_args_by_direction(
         self, direction: PortDeclarationDirection
-    ) -> Dict[str, HandleBinding]:
+    ) -> dict[str, HandleBinding]:
         # This is a hack for handles to wires reduction tests,
         # that initialize function definitions or calls not in the scope of a model,
         # so there is no function resolution annotation.
@@ -199,7 +194,7 @@ class QuantumFunctionCall(QuantumOperation):
 
     def _get_handles_with_declarations(
         self,
-    ) -> Iterable[Tuple[int, AnonPortDeclaration, HandleBinding]]:
+    ) -> Iterable[tuple[int, AnonPortDeclaration, HandleBinding]]:
         return [
             (idx, port, handle)
             for idx, (port, handle) in enumerate(

classiq/interface/model/quantum_function_declaration.py

@@ -1,16 +1,14 @@
+from collections.abc import Sequence
 from typing import (
+    Annotated,
     Any,
-    Dict,
     Literal,
-    Sequence,
-    Set,
     Union,
 )
 
 import pydantic
 from pydantic import SerializeAsAny
 from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Annotated
 
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
@@ -92,11 +90,11 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
         return [param.get_name() for param in self.param_decls]
 
     @property
-    def input_set(self) -> Set[str]:
+    def input_set(self) -> set[str]:
         return {inp.name for inp in self.inputs}
 
     @property
-    def output_set(self) -> Set[str]:
+    def output_set(self) -> set[str]:
         return {output.name for output in self.outputs}
 
     @property
@@ -126,7 +124,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
 
     def ports_by_declaration_direction(
         self, direction: PortDeclarationDirection
-    ) -> Set[str]:
+    ) -> set[str]:
         return {
             port.get_name()
             for port in self.port_declarations
@@ -162,7 +160,7 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
 
     @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", "QuantumOperandDeclaration")
 
     def rename(self, new_name: str) -> "QuantumOperandDeclaration":
@@ -186,7 +184,7 @@ class QuantumOperandDeclaration(
 ):
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _set_none(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+    def _set_none(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         return values
 
 
@@ -209,15 +207,15 @@ class NamedParamsQuantumFunctionDeclaration(QuantumFunctionDeclaration):
     )
 
     @property
-    def port_declarations_dict(self) -> Dict[str, PortDeclaration]:
+    def port_declarations_dict(self) -> dict[str, PortDeclaration]:
         return {port.name: port for port in self.port_declarations}
 
     @property
-    def operand_declarations_dict(self) -> Dict[str, QuantumOperandDeclaration]:
+    def operand_declarations_dict(self) -> dict[str, QuantumOperandDeclaration]:
         return {op.name: op for op in self.operand_declarations}
 
     @property
-    def param_decls_dict(self) -> Dict[str, ClassicalParameterDeclaration]:
+    def param_decls_dict(self) -> dict[str, ClassicalParameterDeclaration]:
         return {param.name: param for param in self.param_decls}
 
     @property

classiq/interface/model/quantum_lambda_function.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 import pydantic
 
@@ -17,12 +17,7 @@ class QuantumLambdaFunction(ASTNode):
     The definition of an anonymous function passed as operand to higher-level functions
     """
 
-    rename_params: Dict[str, str] = pydantic.Field(
-        default_factory=dict,
-        exclude=True,
-    )
-
-    pos_rename_params: List[str] = pydantic.Field(
+    pos_rename_params: list[str] = pydantic.Field(
         default_factory=list,
         description="Mapping of the declared param to the actual variable name used",
     )
@@ -56,14 +51,6 @@ class QuantumLambdaFunction(ASTNode):
     def set_op_decl(self, fd: AnonQuantumOperandDeclaration) -> None:
         self._func_decl = fd
 
-    def get_rename_params(self) -> List[str]:
-        if self.pos_rename_params:
-            return self.pos_rename_params
-        return [
-            self.rename_params.get(cast(str, param.name), cast(str, param.name))
-            for param in self.func_decl.positional_arg_declarations
-        ]
-
 
 QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable]]
+QuantumOperand = Union[QuantumCallable, list[QuantumCallable]]

classiq/interface/model/quantum_statement.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Mapping, Optional, Sequence
+from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
 
 import pydantic
@@ -19,7 +20,7 @@ class QuantumStatement(ASTNode):
 
     @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", cls.__name__)
 
 
@@ -33,7 +34,7 @@ class QuantumOperation(QuantumStatement):
     uuid: UUID = pydantic.Field(
         description="A unique identifier for this operation", default_factory=uuid4
     )
-    _generative_blocks: Dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
+    _generative_blocks: dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:

classiq/interface/model/quantum_type.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 from pydantic import BaseModel, ConfigDict, Field
@@ -74,7 +74,7 @@ class QuantumBit(QuantumScalar):
 
     @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", "qbit")
 
     @property
@@ -98,7 +98,7 @@ class QuantumBitvector(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", "qvec")
 
     def _update_size_in_bits_from_declaration(self) -> None:
@@ -152,7 +152,7 @@ class QuantumNumeric(QuantumScalar):
 
     @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", "qnum")
 
     @pydantic.model_validator(mode="after")
@@ -222,7 +222,7 @@ class RegisterQuantumType(BaseModel):
             return "default"
 
 
-RegisterQuantumTypeDict = Dict[str, RegisterQuantumType]
+RegisterQuantumTypeDict = dict[str, RegisterQuantumType]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric: