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

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]:
@@ -74,6 +75,9 @@ class QuantumOperation(QuantumStatement):
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 
+    def remove_generative_block(self, block_name: str) -> None:
+        self._generative_blocks.pop(block_name)
+
     def get_generative_block(self, block_name: str) -> Callable:
         return self._generative_blocks[block_name]
 

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/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,11 +1,20 @@
+import json
+import uuid
 from collections import defaultdict
+from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
-from functools import cached_property
-from typing import Any, Dict, List, Optional, Sequence, Set, Union
+from functools import cached_property, singledispatch
+from symtable import Symbol
+from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    All_BUILTINS_OPERATORS,
+)
 from classiq.interface.generator.visitor import Visitor
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
@@ -18,8 +27,14 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq import ClassicalParameterDeclaration
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
-from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 
@@ -27,12 +42,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 +57,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)
@@ -51,6 +66,21 @@ class FunctionClosure(Closure):
     is_atomic: bool = False
     signature_scope: Scope = field(default_factory=Scope)
 
+    # creates a unique id for the function closure based on the arguments values.
+    # The closure is changing across the interpreter flow so it's closure_id may change
+    @property
+    def closure_id(self) -> str:
+        # builtins operators have side effects, so  generate a unique id for than
+        # may create a bugs. Therefore, with each call to closure_id a new id is
+        # created
+        if self.is_lambda or self.name in All_BUILTINS_OPERATORS:
+            signature = str(uuid.uuid4())
+        else:
+            signature = _generate_closure_id(
+                self.positional_arg_declarations, self.scope.data.values()
+            )
+        return f"{self.name}__{signature}"
+
     @property
     def body(self) -> Sequence[QuantumStatement]:
         if self.name == permute.func_decl.name:
@@ -59,7 +89,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)
@@ -110,19 +140,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
@@ -163,3 +193,44 @@ class VariableCollector(Visitor):
             defining_function = lambda_environment[var].defining_function
             if defining_function is not None:
                 self._variables[var].add(defining_function.name)
+
+
+def _generate_closure_id(
+    args_declaration: Sequence[PositionalArg], evaluated_args: Collection[Evaluated]
+) -> str:
+    args_signature: dict = {}
+    for arg_declara, eval_arg in zip(args_declaration, evaluated_args):
+        args_signature |= _generate_arg_id(arg_declara, eval_arg)
+    return json.dumps(args_signature)
+
+
+def _generate_arg_id(
+    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_classical_param_to_str(arg_value)}
+    return {arg_name: _evaluated_arg_to_str(arg_value)}
+
+
+@singledispatch
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    return str(uuid.uuid4())
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_symbol_to_str(port: Symbol) -> str:
+    return repr(port)
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.closure_id

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