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

classiq/model_expansions/closure.py

@@ -1,12 +1,14 @@
 from collections import defaultdict
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Any, Dict, List, Optional, Sequence, Set, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.native_function_definition import FunctionSynthesisData
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -27,12 +29,12 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 @dataclass(frozen=True)
 class Closure:
     name: str
-    blocks: Dict[str, Sequence[QuantumStatement]]
+    blocks: dict[str, Sequence[QuantumStatement]]
     scope: Scope
     positional_arg_declarations: Sequence[PositionalArg] = tuple()
 
-    @cached_property
-    def port_declarations(self) -> Dict[str, PortDeclaration]:
+    @property
+    def port_declarations(self) -> dict[str, PortDeclaration]:
         return {
             param.name: param
             for param in self.positional_arg_declarations
@@ -42,7 +44,7 @@ class Closure:
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):
-    generative_blocks: Dict[str, GenerativeQFunc] = None  # type:ignore[assignment]
+    generative_blocks: dict[str, GenerativeQFunc] = None  # type:ignore[assignment]
 
 
 @dataclass(frozen=True)
@@ -50,6 +52,7 @@ class FunctionClosure(Closure):
     is_lambda: bool = False
     is_atomic: bool = False
     signature_scope: Scope = field(default_factory=Scope)
+    synthesis_data: FunctionSynthesisData = field(default_factory=FunctionSynthesisData)
 
     @property
     def body(self) -> Sequence[QuantumStatement]:
@@ -59,7 +62,7 @@ class FunctionClosure(Closure):
         return self.blocks["body"]
 
     @cached_property
-    def colliding_variables(self) -> Set[str]:
+    def colliding_variables(self) -> set[str]:
         # Note that this has to be accessed after adding the parameters from the signature and not during
         # initialization
         return VariableCollector(self.scope).get_colliding_variables(self.body)
@@ -74,6 +77,7 @@ class FunctionClosure(Closure):
         expr_renamer: Optional[ExpressionRenamer] = None,
         is_lambda: bool = False,
         is_atomic: bool = False,
+        synthesis_data: Optional[FunctionSynthesisData] = None,
         **kwargs: Any,
     ) -> Self:
         if expr_renamer:
@@ -86,6 +90,9 @@ class FunctionClosure(Closure):
                 body = expr_renamer.visit(body)
 
         blocks = {"body": body} if body is not None else {}
+        synthesis_data = (
+            synthesis_data if synthesis_data is not None else FunctionSynthesisData()
+        )
         return cls(
             name,
             blocks,
@@ -93,6 +100,7 @@ class FunctionClosure(Closure):
             positional_arg_declarations,
             is_lambda,
             is_atomic,
+            synthesis_data=synthesis_data,
             **kwargs,
         )
 
@@ -110,19 +118,19 @@ class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
 
 
-NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]
+NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
 
 
 class VariableCollector(Visitor):
     def __init__(self, function_scope: Scope) -> None:
         self._function_scope = function_scope
-        self._variables: defaultdict[str, Set[Optional[str]]] = defaultdict(set)
+        self._variables: defaultdict[str, set[Optional[str]]] = defaultdict(set)
         for var in self._function_scope.data:
             defining_function = self._function_scope[var].defining_function
             if defining_function is not None:
                 self._variables[var].add(defining_function.name)
 
-    def get_colliding_variables(self, body: Sequence[QuantumStatement]) -> Set[str]:
+    def get_colliding_variables(self, body: Sequence[QuantumStatement]) -> set[str]:
         self.visit(body)
         return {
             var

classiq/model_expansions/evaluators/arg_type_match.py

@@ -1,5 +1,6 @@
+from collections.abc import Sequence
 from enum import Enum
-from typing import Any, List, Sequence
+from typing import Any
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -31,7 +32,7 @@ from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
 def check_type_match(
     parameters: Sequence[AnonPositionalArg],
-    arguments: List[Evaluated],
+    arguments: list[Evaluated],
     function_name: str,
 ) -> None:
     if len(parameters) != len(arguments):

classiq/model_expansions/evaluators/argument_types.py

@@ -1,4 +1,4 @@
-from typing import List, Sequence
+from collections.abc import Sequence
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -12,8 +12,8 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 def add_information_from_output_arguments(
     parameters: Sequence[AnonPositionalArg],
-    args: List[Evaluated],
-) -> List[Evaluated]:
+    args: list[Evaluated],
+) -> list[Evaluated]:
     """
     This function propagates the quantum type information from the output arguments
     to the arguments that were passed to it.

classiq/model_expansions/evaluators/control.py

@@ -1,4 +1,4 @@
-from typing import Any, Tuple
+from typing import Any
 
 from sympy import Equality
 from sympy.core.numbers import Number
@@ -19,7 +19,7 @@ def type_name(obj: Any) -> str:
     return type(obj).__name__
 
 
-def resolve_num_condition(condition: Equality) -> Tuple[QmodSizedProxy, str]:
+def resolve_num_condition(condition: Equality) -> tuple[QmodSizedProxy, str]:
     ctrl, ctrl_val = condition.args
     if isinstance(ctrl, Number) and isinstance(ctrl_val, QmodQScalarProxy):
         ctrl, ctrl_val = ctrl_val, ctrl
@@ -41,7 +41,7 @@ def _calculate_ctrl_state(ctrl: QmodSizedProxy, ctrl_val: float) -> str:
     return _to_twos_complement(integer_ctrl_val, ctrl.size)
 
 
-def _get_numeric_attributes(ctrl: QmodSizedProxy) -> Tuple[bool, int]:
+def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
     return (
         (ctrl.is_signed, ctrl.fraction_digits)
         if isinstance(ctrl, QmodQNumProxy)

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,4 +1,4 @@
-from typing import List, Set, Union
+from typing import Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -41,8 +41,8 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 
 
 def evaluate_parameter_types_from_args(
-    closure: FunctionClosure, signature_scope: Scope, arguments: List[Evaluated]
-) -> List[PositionalArg]:
+    closure: FunctionClosure, signature_scope: Scope, arguments: list[Evaluated]
+) -> list[PositionalArg]:
     parameters = closure.positional_arg_declarations
     function_name = closure.name
     check_type_match(parameters, arguments, function_name)
@@ -90,12 +90,12 @@ def _update_scope(
     )
 
 
-NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]
+NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
 
 
 def _update_operand_signature_environment(
     operand_val: NestedFunctionClosureT,
-    parameter_names: Set[str],
+    parameter_names: set[str],
     closure: FunctionClosure,
 ) -> None:
     # We update the environment (parent) of the operand by adding closure.scope.data,
@@ -203,8 +203,8 @@ def _evaluate_qstruct_in_quantum_symbol(
 
 
 def evaluate_types_in_quantum_symbols(
-    symbols: List[QuantumSymbol], scope: Scope
-) -> List[QuantumSymbol]:
+    symbols: list[QuantumSymbol], scope: Scope
+) -> list[QuantumSymbol]:
     return [
         QuantumSymbol(
             handle=symbol.handle,

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,4 +1,5 @@
-from typing import Mapping, Optional
+from collections.abc import Mapping
+from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,

classiq/model_expansions/evaluators/type_type_match.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,

classiq/model_expansions/expression_evaluator.py

@@ -1,6 +1,7 @@
 import ast
+from collections.abc import Mapping
 from enum import EnumMeta
-from typing import Any, Dict, List, Mapping, Optional, Set
+from typing import Any, Optional
 
 from sympy import sympify
 
@@ -30,14 +31,14 @@ from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_p
 from classiq.qmod import symbolic
 
 
-def evaluate_constants(constants: List[Constant]) -> Dict[str, EvaluatedExpression]:
-    result: Dict[str, EvaluatedExpression] = {}
+def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
+    result: dict[str, EvaluatedExpression] = {}
     for constant in constants:
         result[constant.name] = evaluate(constant.value, result)
     return result
 
 
-def evaluate_constants_as_python(constants: List[Constant]) -> Dict[str, Any]:
+def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     evaluated = evaluate_constants(constants)
     return {
         constant.name: qmod_val_to_python(
@@ -50,9 +51,9 @@ def evaluate_constants_as_python(constants: List[Constant]) -> Dict[str, Any]:
 def evaluate(
     expr: Expression,
     locals_dict: Mapping[str, EvaluatedExpression],
-    uninitialized_locals: Optional[Set[str]] = None,
+    uninitialized_locals: Optional[set[str]] = None,
 ) -> EvaluatedExpression:
-    model_locals: Dict[str, ExpressionValue] = {}
+    model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
     model_locals.update(SymbolTable.enum_table.enums)
     # locals override builtin-functions
@@ -81,8 +82,8 @@ def evaluate(
 
 def _validate_undefined_vars(
     expr: str,
-    model_locals: Dict[str, ExpressionValue],
-    uninitialized_locals: Optional[Set[str]],
+    model_locals: dict[str, ExpressionValue],
+    uninitialized_locals: Optional[set[str]],
 ) -> None:
     uninitialized_locals = uninitialized_locals or set()
     id_visitor = _VarsCollector()
@@ -110,7 +111,7 @@ def _validate_undefined_vars(
 
 class _VarsCollector(ast.NodeTransformer):
     def __init__(self) -> None:
-        self.vars: Set[str] = set()
+        self.vars: set[str] = set()
 
     def visit_Name(self, node: ast.Name) -> None:
         self.vars.add(node.id)

classiq/model_expansions/expression_renamer.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Dict, Sequence
+from collections.abc import Sequence
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
@@ -17,11 +17,11 @@ from classiq.model_expansions.visitors.variable_references import VarRefTransfor
 
 class ExpressionRenamer(Transformer):
 
-    def __init__(self, var_mapping: Dict[str, str]) -> None:
+    def __init__(self, var_mapping: dict[str, str]) -> None:
         self.var_ref_transformer = VarRefTransformer(var_mapping)
 
     @property
-    def var_mapping(self) -> Dict[str, str]:
+    def var_mapping(self) -> dict[str, str]:
         return self.var_ref_transformer.var_mapping
 
     def visit_QuantumFunctionCall(
@@ -41,8 +41,8 @@ class ExpressionRenamer(Transformer):
         return self.var_mapping.get(name, name)
 
     def rename_expression_dict(
-        self, expr_dict: Dict[str, Expression]
-    ) -> Dict[str, Expression]:
+        self, expr_dict: dict[str, Expression]
+    ) -> dict[str, Expression]:
         return {
             self.rename_string(key): self.visit(val) for key, val in expr_dict.items()
         }
@@ -51,7 +51,7 @@ class ExpressionRenamer(Transformer):
     def from_positional_arg_declarations(
         cls, positional_arg_declarations: Sequence[PositionalArg], suffix: str
     ) -> "ExpressionRenamer":
-        var_mapping: Dict[str, str] = dict()
+        var_mapping: dict[str, str] = dict()
         for arg in positional_arg_declarations:
             if not isinstance(arg, ClassicalParameterDeclaration):
                 continue

classiq/model_expansions/function_builder.py

@@ -1,6 +1,7 @@
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Dict, Generic, Iterable, Iterator, List, Optional, Sequence, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -18,6 +19,7 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
+    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -35,14 +37,14 @@ ClosureType = TypeVar("ClosureType", bound=Closure)
 
 @dataclass
 class Block:
-    statements: List[QuantumStatement] = field(default_factory=list)
-    captured_vars: List[PortDeclaration] = field(default_factory=list)
+    statements: list[QuantumStatement] = field(default_factory=list)
+    captured_vars: list[PortDeclaration] = field(default_factory=list)
 
 
 @dataclass
 class OperationContext(Generic[ClosureType]):
     closure: ClosureType
-    blocks: Dict[str, Block] = field(default_factory=dict)
+    blocks: dict[str, Block] = field(default_factory=dict)
 
     @property
     def name(self) -> str:
@@ -52,7 +54,7 @@ class OperationContext(Generic[ClosureType]):
     def positional_arg_declarations(self) -> Sequence[PositionalArg]:
         return self.closure.positional_arg_declarations
 
-    def statements(self, block_name: str) -> List[QuantumStatement]:
+    def statements(self, block_name: str) -> list[QuantumStatement]:
         return self.blocks[block_name].statements
 
 
@@ -63,22 +65,26 @@ class FunctionContext(OperationContext[FunctionClosure]):
         return cls(original_function, {"body": Block()})
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self.statements("body")
 
     @property
-    def captured_vars(self) -> List[PortDeclaration]:
+    def captured_vars(self) -> list[PortDeclaration]:
         return self.blocks["body"].captured_vars
 
     @property
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
+    @property
+    def synthesis_data(self) -> FunctionSynthesisData:
+        return self.closure.synthesis_data
+
 
 class OperationBuilder:
     def __init__(self) -> None:
-        self._operations: List[OperationContext] = []
-        self._blocks: List[str] = []
+        self._operations: list[OperationContext] = []
+        self._blocks: list[str] = []
         self._counter = 0
 
     @property
@@ -93,7 +99,7 @@ class OperationBuilder:
         raise ClassiqInternalExpansionError("No function found")
 
     @property
-    def _current_statements(self) -> List[QuantumStatement]:
+    def _current_statements(self) -> list[QuantumStatement]:
         return self._operations[-1].blocks[self._blocks[-1]].statements
 
     def emit_statement(self, statement: QuantumStatement) -> None:
@@ -160,7 +166,7 @@ class OperationBuilder:
             name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
             self._counter += 1
 
-        new_parameters: List[PortDeclaration] = [
+        new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations
             if isinstance(param, PortDeclaration)
@@ -170,10 +176,11 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=new_parameters,
+            synthesis_data=function_context.synthesis_data,
         )
 
 
-def validate_captured_vars(captured_vars: List[PortDeclaration]) -> None:
+def validate_captured_vars(captured_vars: list[PortDeclaration]) -> None:
     if input_captured := [
         demangle_name(var.name)
         for var in captured_vars

classiq/model_expansions/generative_functions.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, List, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
@@ -127,7 +128,7 @@ class _InterpreterExpandable(QFunc):
 def emit_generative_statements(
     interpreter: "Interpreter",
     operation: GenerativeClosure,
-    args: List[Evaluated],
+    args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
         translate_ast_arg_to_python_qmod(param, arg)

classiq/model_expansions/interpreter.py

@@ -1,7 +1,8 @@
 import copy
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager, nullcontext
 from functools import singledispatchmethod
-from typing import Any, Iterator, List, Optional, Sequence, Tuple, Type, cast
+from typing import Any, Optional, cast
 
 import numpy as np
 from numpy.random import permutation
@@ -45,6 +46,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.call_to_model_converter import BlockFunctionInfo
 from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVarStack
 from classiq.model_expansions.closure import (
     Closure,
@@ -88,7 +90,7 @@ from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
-STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement], ...] = (
+STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: tuple[type[QuantumStatement], ...] = (
     QuantumFunctionCall,
     VariableDeclarationStatement,
     QuantumAssignmentOperation,
@@ -99,14 +101,14 @@ class Interpreter:
     def __init__(
         self,
         model: Model,
-        generative_functions: Optional[List[GenerativeQFunc]] = None,
+        generative_functions: Optional[list[GenerativeQFunc]] = None,
         is_frontend: bool = False,
     ) -> None:
         self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
-        self._expanded_functions: List[NativeFunctionDefinition] = []
+        self._expanded_functions: list[NativeFunctionDefinition] = []
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
         )
@@ -120,6 +122,7 @@ class Interpreter:
 
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
+        self._synthesized_separately_blocks: dict[str, BlockFunctionInfo] = {}
 
     @contextmanager
     def _scope_guard(self, scope: Scope) -> Iterator[None]:
@@ -154,9 +157,10 @@ class Interpreter:
             self._builder.create_definition(cast(FunctionContext, context))
         )
 
-    def expand(self) -> Model:
+    def expand(self) -> tuple[Model, dict[str, BlockFunctionInfo]]:
         try:
             with self._error_manager.call("main"):
+                self._synthesized_separately_blocks = {}
                 self._expand_main_func()
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
@@ -168,17 +172,20 @@ class Interpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return Model(
-            constraints=self._model.constraints,
-            preferences=self._model.preferences,
-            classical_execution_code=self._model.classical_execution_code,
-            execution_preferences=self._model.execution_preferences,
-            functions=self._expanded_functions,
-            constants=self._model.constants,
-            enums=self._model.enums,
-            types=self._model.types,
-            qstructs=self._model.qstructs,
-            debug_info=self._model.debug_info,
+        return (
+            Model(
+                constraints=self._model.constraints,
+                preferences=self._model.preferences,
+                classical_execution_code=self._model.classical_execution_code,
+                execution_preferences=self._model.execution_preferences,
+                functions=self._expanded_functions,
+                constants=self._model.constants,
+                enums=self._model.enums,
+                types=self._model.types,
+                qstructs=self._model.qstructs,
+                debug_info=self._model.debug_info,
+            ),
+            self._synthesized_separately_blocks,
         )
 
     @singledispatchmethod
@@ -196,7 +203,7 @@ class Interpreter:
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         renamed_params = [
-            param.rename(function.get_rename_params()[idx])
+            param.rename(function.pos_rename_params[idx])
             for idx, param in enumerate(function.func_decl.positional_arg_declarations)
         ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
@@ -204,7 +211,7 @@ class Interpreter:
             positional_arg_declarations=renamed_params,
         )
 
-        closure_class: Type[FunctionClosure]
+        closure_class: type[FunctionClosure]
         extra_args: dict[str, Any]
         if function.is_generative():
             closure_class = GenerativeFunctionClosure
@@ -339,7 +346,12 @@ class Interpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            if (
+                isinstance(operation, FunctionClosure)
+                and operation.synthesis_data.should_synthesize_separately
+            ):
+                pass
+            elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
                 with self._scope_guard(operation.scope):
                     self._expand_permute()

classiq/model_expansions/model_tables.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import IntEnum
-from typing import ClassVar, Dict, Generic, List, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -18,15 +18,15 @@ DeclarationType = TypeVar(
 
 
 class TypeTable(Generic[DeclarationType], ABC):
-    def __init__(self, user_types: List[DeclarationType]) -> None:
-        self._all_types: Dict[str, DeclarationType] = self.builtins.copy()
+    def __init__(self, user_types: list[DeclarationType]) -> None:
+        self._all_types: dict[str, DeclarationType] = self.builtins.copy()
         for t in user_types:
             assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
             self._all_types[t.name] = t
 
     @property
     @abstractmethod
-    def builtins(self) -> Dict[str, DeclarationType]:
+    def builtins(self) -> dict[str, DeclarationType]:
         pass
 
     def __getitem__(self, key: str) -> DeclarationType:
@@ -38,20 +38,20 @@ class TypeTable(Generic[DeclarationType], ABC):
     def __contains__(self, key: str) -> bool:
         return key in self._all_types
 
-    def all_types(self) -> Dict[str, DeclarationType]:
+    def all_types(self) -> dict[str, DeclarationType]:
         return self._all_types
 
 
 class EnumTable(TypeTable[EnumDeclaration]):
-    def __init__(self, user_types: List[EnumDeclaration]) -> None:
+    def __init__(self, user_types: list[EnumDeclaration]) -> None:
         super().__init__(user_types)
 
     @property
-    def builtins(self) -> Dict[str, EnumDeclaration]:
+    def builtins(self) -> dict[str, EnumDeclaration]:
         return BUILTIN_ENUM_DECLARATIONS
 
     @property
-    def enums(self) -> Dict[str, IntEnum]:
+    def enums(self) -> dict[str, IntEnum]:
         return {
             enum_decl.name: enum_decl.create_enum()
             for enum_decl in self.all_types().values()
@@ -60,13 +60,13 @@ class EnumTable(TypeTable[EnumDeclaration]):
 
 class StructTable(TypeTable[StructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, StructDeclaration]:
+    def builtins(self) -> dict[str, StructDeclaration]:
         return BUILTIN_STRUCT_DECLARATIONS
 
 
 class QStructTable(TypeTable[QStructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, QStructDeclaration]:
+    def builtins(self) -> dict[str, QStructDeclaration]:
         return {}
 
 
@@ -76,15 +76,15 @@ class SymbolTable:
     qstruct_table: ClassVar[QStructTable] = QStructTable([])
 
     @classmethod
-    def init_user_enums(cls, user_enums: List[EnumDeclaration]) -> None:
+    def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
         cls.enum_table = EnumTable(user_enums)
 
     @classmethod
-    def init_user_types(cls, user_types: List[StructDeclaration]) -> None:
+    def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
         cls.type_table = StructTable(user_types)
 
     @classmethod
-    def init_user_qstructs(cls, user_qstructs: List[QStructDeclaration]) -> None:
+    def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:
         cls.qstruct_table = QStructTable(user_qstructs)
         QMODULE.qstruct_decls = {
             qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
@@ -92,7 +92,7 @@ class SymbolTable:
 
 
 class HandleTable:
-    _handle_map: Dict[HandleIdentifier, QmodPyObject] = {}
+    _handle_map: dict[HandleIdentifier, QmodPyObject] = {}
 
     @classmethod
     def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]: