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

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:

classiq/interface/model/statement_block.py

@@ -1,7 +1,6 @@
-from typing import List, Union
+from typing import Annotated, Union
 
 from pydantic import Field
-from typing_extensions import Annotated
 
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -44,7 +43,7 @@ ConcreteQuantumStatement = Annotated[
     Field(..., discriminator="kind"),
 ]
 
-StatementBlock = List[ConcreteQuantumStatement]
+StatementBlock = list[ConcreteQuantumStatement]
 
 Control.model_rebuild()
 QuantumLambdaFunction.model_rebuild()

classiq/interface/model/validation_handle.py

@@ -1,6 +1,7 @@
 import dataclasses
+from collections.abc import Mapping
 from enum import Enum
-from typing import List, Mapping, Optional, Set
+from typing import Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.handle_binding import HandleBinding
@@ -22,12 +23,12 @@ class HandleState(Enum):
 @dataclasses.dataclass
 class ValidationHandle:
     _state: HandleState
-    errors: List[str] = dataclasses.field(default_factory=list)
+    errors: list[str] = dataclasses.field(default_factory=list)
 
     def __init__(
         self,
         initial_state: Optional[HandleState] = None,
-        errors: Optional[List[str]] = None,
+        errors: Optional[list[str]] = None,
     ) -> None:
         if initial_state is None and not errors:
             raise ClassiqError("Missing initial state for ValidationHandle")
@@ -50,5 +51,5 @@ class ValidationHandle:
         self._state = HandleState.UNINITIALIZED
 
 
-def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> Set[str]:
+def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> set[str]:
     return {handle_binding.name for handle_binding in io_dict.values()}

classiq/interface/server/global_versions.py

@@ -1,5 +1,5 @@
 from datetime import date
-from typing import Any, Dict
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -10,5 +10,5 @@ class DeprecationInfo(BaseModel):
 
 
 class GlobalVersions(BaseModel):
-    deprecated: Dict[str, DeprecationInfo]
-    deployed: Dict[str, Any]
+    deprecated: dict[str, DeprecationInfo]
+    deployed: dict[str, Any]

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Callable, List, Mapping, Union
+from typing import Any, Callable, Union
 
 from sympy import Eq, Expr, Number, Piecewise, Symbol
 
@@ -229,7 +230,7 @@ def do_slice(value: Any, lower: Any, upper: Any) -> Any:
     return do_subscript(value, slice(lower, upper))
 
 
-CORE_LIB_FUNCTIONS_LIST: List[Callable] = [
+CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
     sum,
     struct_literal,

classiq/model_expansions/call_to_model_converter.py

@@ -0,0 +1,190 @@
+import dataclasses
+import json
+from collections.abc import Iterator, Sequence
+from functools import cached_property
+from typing import Any, Union
+
+from typing_extensions import Self
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_type import QuantumType
+
+from classiq import ClassicalParameterDeclaration
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, evaluated_to_str
+
+
+@dataclasses.dataclass(frozen=False)
+class BlockFunctionInfo:
+    block_id: str
+    model: Model
+    inputs: set[str]
+    outputs: set[str]
+    inouts: set[str]
+    calls: set[str] = dataclasses.field(default_factory=set)
+
+    @classmethod
+    def from_call_converter(cls, call_converter: "CallToModelConverter") -> Self:
+        return cls(
+            block_id=call_converter.block_id,
+            model=call_converter.convert(),
+            inputs=set(call_converter.call.wiring_inputs),
+            outputs=set(call_converter.call.wiring_outputs),
+            inouts=set(call_converter.call.wiring_inouts),
+        )
+
+
+class CallToModelConverter:
+
+    def __init__(
+        self,
+        call: QuantumFunctionCall,
+        positional_arg_declarations: Sequence[PositionalArg],
+        evaluated_arg: dict[str, Evaluated],
+        model: Model,
+    ) -> None:
+        self.call = call
+        self._positional_arg_declarations = positional_arg_declarations
+        self._evaluated_arg = evaluated_arg
+
+        self._model = model
+
+    @cached_property
+    def block_id(self) -> str:
+        args_signature: dict = {}
+        for arg_declaration, evaluated_arg in zip(
+            self._positional_arg_declarations,
+            self._evaluated_arg.values(),
+        ):
+            args_signature |= _get_arg_signature(arg_declaration, evaluated_arg)
+        return f"{self.call.func_name}__{json.dumps(args_signature)}"
+
+    def convert(self) -> Model:
+        return self._model.model_copy(
+            update={"functions": self._update_model_functions()}
+        )
+
+    def _update_model_functions(self) -> list[NativeFunctionDefinition]:
+        return [
+            (
+                self._create_new_main_function()
+                if function.name == MAIN_FUNCTION_NAME
+                else (
+                    function.model_copy(update={"synthesis_data": None})
+                    if function.name == self.call.function
+                    else function
+                )
+            )
+            for function in self._model.functions
+        ]
+
+    def _create_new_main_function(self) -> NativeFunctionDefinition:
+        return NativeFunctionDefinition(
+            name=MAIN_FUNCTION_NAME,
+            positional_arg_declarations=self._make_all_ports_outputs(),
+            body=[*self._allocate_ports(), self._update_call()],
+        )
+
+    def _make_all_ports_outputs(self) -> list[PortDeclaration]:
+        return [
+            _convert_port_to_output(port_declaration)
+            for port_declaration in self._positional_arg_declarations
+            if isinstance(port_declaration, PortDeclaration)
+        ]
+
+    def _allocate_ports(self) -> Iterator[QuantumFunctionCall]:
+        return (
+            QuantumFunctionCall(
+                function="allocate",
+                positional_args=[
+                    self._get_allocation_size(port_declaration.name),
+                    HandleBinding(name=port_declaration.name),
+                ],
+            )
+            for port_declaration in self._positional_arg_declarations
+            if isinstance(port_declaration, PortDeclaration)
+            and port_declaration.direction != PortDeclarationDirection.Output
+        )
+
+    def _get_allocation_size(self, port_declara_name: str) -> Expression:
+        port_value = self._evaluated_arg[port_declara_name].value
+        return Expression(expr=_get_reg_size(port_value, port_declara_name))
+
+    def _update_call(self) -> QuantumFunctionCall:
+        return self.call.model_copy(
+            update={"positional_args": self._evaluate_positional_args()}
+        )
+
+    def _evaluate_positional_args(self) -> list[ArgValue]:
+        return [
+            _get_positional_arg(arg, evaluated_arg)
+            for arg, evaluated_arg in zip(
+                self._positional_arg_declarations,
+                self._evaluated_arg.values(),
+            )
+        ]
+
+
+def _validate_quantum_type(port: Any, port_declara_name: str) -> QuantumType:
+    if not isinstance(port, QuantumSymbol):
+        raise ClassiqExpansionError(f"Port {port_declara_name!r} has incorrect type")
+    return port.quantum_type
+
+
+def _get_reg_size(port: Any, port_declara_name: str) -> str:
+    quantum_type = _validate_quantum_type(port, port_declara_name)
+    return str(quantum_type.size_in_bits)
+
+
+def _get_arg_signature(
+    arg_declaration: PositionalArg, evaluated_arg: Evaluated
+) -> dict[str, str]:
+    arg_value = evaluated_arg.value
+    arg_name = arg_declaration.name
+    if isinstance(arg_declaration, ClassicalParameterDeclaration):
+        return {arg_name: evaluated_to_str(arg_value)}
+    if isinstance(arg_declaration, PortDeclaration):
+        quantum_type = _validate_quantum_type(arg_value, arg_name)
+        return {
+            arg_name: quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+        }
+    if isinstance(arg_declaration, QuantumOperandDeclaration):
+        raise NotImplementedError(
+            f"Synthesize separately does not support input operand: {arg_declaration.name!r}"
+        )
+
+
+def _get_positional_arg(
+    arg_declaration: PositionalArg, evaluated_arg: Evaluated
+) -> Union[Expression, HandleBinding]:
+    if isinstance(arg_declaration, ClassicalParameterDeclaration):
+        return Expression(expr=evaluated_to_str(evaluated_arg.value))
+    if isinstance(arg_declaration, PortDeclaration):
+        return HandleBinding(name=arg_declaration.name)
+    if isinstance(arg_declaration, QuantumOperandDeclaration):
+        raise NotImplementedError(
+            f"Synthesize separately does not support input operand: {arg_declaration.name!r}"
+        )
+
+
+def _convert_port_to_output(port: PortDeclaration) -> PortDeclaration:
+    if port.direction == PortDeclarationDirection.Output:
+        return port
+    elif port.direction == PortDeclarationDirection.Inout:
+        return port.model_copy(update={"direction": PortDeclarationDirection.Output})
+    else:
+        raise NotImplementedError(
+            f"Synthesize separately does not support input ports: {port.name!r}"
+        )

classiq/model_expansions/capturing/captured_var_manager.py

@@ -1,21 +1,19 @@
-from typing import Dict, List
-
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
 
 
-def update_captured_vars(captured_vars: List[PortDeclaration]) -> List[PortDeclaration]:
+def update_captured_vars(captured_vars: list[PortDeclaration]) -> list[PortDeclaration]:
     if not captured_vars:
         return []
     return _update_declarations(captured_vars)
 
 
 def _update_declarations(
-    captured_vars: List[PortDeclaration],
-) -> List[PortDeclaration]:
-    updated_vars: Dict[str, PortDeclaration] = {
+    captured_vars: list[PortDeclaration],
+) -> list[PortDeclaration]:
+    updated_vars: dict[str, PortDeclaration] = {
         var.name: PortDeclaration(
             name=var.name,
             quantum_type=var.quantum_type,

classiq/model_expansions/capturing/propagated_var_stack.py

@@ -1,6 +1,6 @@
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import Dict, Iterable, Iterator, List, Sequence
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -34,10 +34,10 @@ class PropagatedVariable:
 class PropagatedVarStack:
     def __init__(self, scope: Scope, builder: OperationBuilder) -> None:
         # We use dictionary instead of set to maintain the order of insertion
-        self._stack: List[Dict[PropagatedVariable, None]] = [dict()]
+        self._stack: list[dict[PropagatedVariable, None]] = [dict()]
         self._current_scope = scope
         self._builder = builder
-        self._to_mangle: Dict[PropagatedVariable, str] = dict()
+        self._to_mangle: dict[PropagatedVariable, str] = dict()
 
     def set_scope(self, scope: Scope) -> None:
         self._current_scope = scope
@@ -71,7 +71,7 @@ class PropagatedVarStack:
 
     def _get_captured_vars(
         self, qop: QuantumOperation
-    ) -> Dict[PropagatedVariable, None]:
+    ) -> dict[PropagatedVariable, None]:
         input_captured = self._get_captured_vars_with_direction(
             qop.inputs,
             (
@@ -97,7 +97,7 @@ class PropagatedVarStack:
         self,
         variables: Iterable[HandleBinding],
         direction: PortDeclarationDirection,
-    ) -> Dict[PropagatedVariable, None]:
+    ) -> dict[PropagatedVariable, None]:
         return {
             self._get_captured_var_with_direction(var.name, direction): None
             for var in variables
@@ -133,8 +133,8 @@ class PropagatedVarStack:
             for var in self._stack[-1]
         )
 
-    def get_propagated_variables(self) -> List[HandleBinding]:
-        propagated_var_names: List[str] = [
+    def get_propagated_variables(self) -> list[HandleBinding]:
+        propagated_var_names: list[str] = [
             self._get_propagated_var_name(var) for var in self._stack[-1]
         ]
         return [