classiq 0.53.0__py3-none-any.whl → 0.55.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,18 @@
-from typing import Any, Dict, List, Optional, Tuple
+from collections import Counter
+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 +24,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: Counter[str] = 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 +55,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 +105,14 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
-    children: List["Operation"]
+    details: str = pydantic.Field(default="")
+    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/control.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
+from classiq.interface.model.quantum_type import QuantumType
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
@@ -13,8 +15,12 @@ if TYPE_CHECKING:
 class Control(QuantumExpressionOperation):
     kind: Literal["Control"]
     body: "StatementBlock"
+    else_block: Optional["StatementBlock"] = None
 
     _ctrl_size: int = pydantic.PrivateAttr(default=0)
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
 
     @property
     def ctrl_size(self) -> int:
@@ -22,3 +28,18 @@ class Control(QuantumExpressionOperation):
 
     def set_ctrl_size(self, ctrl_size: int) -> None:
         self._ctrl_size = ctrl_size
+
+    @property
+    def result_type(self) -> QuantumType:
+        assert self._result_type is not None
+        return self._result_type
+
+    def initialize_var_types(
+        self,
+        var_types: dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
+        super().initialize_var_types(var_types, machine_precision)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types, machine_precision
+        )

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
 
@@ -14,6 +15,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -58,23 +60,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 +85,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,
     )
 
@@ -97,6 +99,9 @@ class Model(VersionedModel, ASTNode):
     debug_info: DebugInfoCollection = pydantic.Field(
         default_factory=DebugInfoCollection
     )
+    functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
+        default_factory=dict
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:
@@ -133,8 +138,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 +151,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 +166,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/native_function_definition.py

@@ -29,5 +29,5 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
         default_factory=list, description="List of function calls to perform."
     )
     synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData,
+        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
     )

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,7 +1,5 @@
-from typing import Dict, Literal, Mapping, Optional, Sequence
-
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
@@ -28,28 +26,7 @@ class ArithmeticOperationKind(StrEnum):
 class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
-    inplace_result: Optional[bool] = pydantic.Field(
-        description="Determines whether the result variable is initialized",
-        default=None,
-        exclude=True,
-    )
-
-    operation_kind: ArithmeticOperationKind = pydantic.Field(
-        default=None, validate_default=True
-    )
-
-    @pydantic.field_validator("operation_kind", mode="before")
-    @classmethod
-    def _propagate_inplace_result(
-        cls, operation_kind: Optional[ArithmeticOperationKind], info: ValidationInfo
-    ) -> ArithmeticOperationKind:
-        if operation_kind is None:
-            operation_kind = (
-                ArithmeticOperationKind.InplaceXor
-                if info.data["inplace_result"]
-                else ArithmeticOperationKind.Assignment
-            )
-        return operation_kind
+    operation_kind: ArithmeticOperationKind
 
     @property
     def is_inplace(self) -> bool:
@@ -60,7 +37,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