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

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 [

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