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

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, List, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Union
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
@@ -16,11 +18,7 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_type import (
-    QuantumBit,
-    QuantumBitvector,
-    QuantumNumeric,
-)
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -38,6 +36,7 @@ from classiq.model_expansions.scope import QuantumSymbol, Scope
 from classiq.qmod.builtins.functions import (
     CX,
     allocate,
+    apply_to_all,
     integer_xor,
     modular_add,
     modular_add_constant,
@@ -94,6 +93,18 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             handle=HandleBinding(name="target"),
             quantum_type=target_var.quantum_type,
         )
+        internal_func_decl = _binary_function_declaration(op.operation, constant=False)
+        if op.operation == BinaryOperation.Xor:
+            body = _build_inplace_xor_operation(
+                value_var=value_var,
+                target_var=target_var,
+            )
+        else:
+            body = _build_inplace_binary_operation(
+                value_var=value_var,
+                target_var=target_var,
+                internal_function_declaration=internal_func_decl,
+            )
         inplace_binary_op_function = FunctionClosure.create(
             name=op.operation.value,
             positional_arg_declarations=[
@@ -108,13 +119,7 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
                     direction=PortDeclarationDirection.Inout,
                 ),
             ],
-            body=_build_inplace_binary_operation(
-                value_var=value_var,
-                target_var=target_var,
-                internal_function_declaration=_binary_function_declaration(
-                    op.operation, constant=False
-                ),
-            ),
+            body=body,
             scope=Scope(parent=self._current_scope),
         )
         with self._propagated_var_stack.capture_variables(op):
@@ -139,7 +144,7 @@ def _build_inplace_binary_operation(
     value_var: QuantumSymbol,
     target_var: QuantumSymbol,
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
-) -> List[QuantumStatement]:
+) -> list[QuantumStatement]:
     if TYPE_CHECKING:
         assert isinstance(value_var.quantum_type, QuantumNumeric)
         assert isinstance(target_var.quantum_type, QuantumNumeric)
@@ -192,6 +197,54 @@ def _build_inplace_binary_operation(
     ]
 
 
+def _build_inplace_xor_operation(
+    value_var: QuantumSymbol, target_var: QuantumSymbol
+) -> list[QuantumStatement]:
+    if TYPE_CHECKING:
+        assert isinstance(value_var.quantum_type, QuantumNumeric)
+        assert isinstance(target_var.quantum_type, QuantumNumeric)
+
+    frac_digits_diff = (
+        value_var.quantum_type.fraction_digits_value
+        - target_var.quantum_type.fraction_digits_value
+    )
+
+    target_overlap_var, target_var_decls, target_bind_ops = (
+        _trim_superfluous_fraction_digits("target", target_var, -frac_digits_diff)
+    )
+    value_overlap_var, value_trim_var_decls, value_bind_ops = (
+        _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
+    )
+    target_left_var, value_left_var, sign_var_decls, sign_bind_ops, sign_xor = (
+        _split_and_xor_sign(target_overlap_var, value_overlap_var)
+    )
+
+    action: list[QuantumStatement] = []
+    if target_left_var is not None and value_left_var is not None:
+        action.append(
+            _internal_inplace_binary_operation_function_call(
+                integer_xor.func_decl,
+                value_left_var.handle,
+                target_left_var.handle,
+            )
+        )
+    action.extend(sign_xor)
+
+    return [
+        *target_var_decls,
+        *value_trim_var_decls,
+        *sign_var_decls,
+        WithinApply(
+            compute=[
+                *target_bind_ops,
+                *value_bind_ops,
+                *sign_bind_ops,
+            ],
+            action=action,
+        ),
+    ]
+
+
 def _internal_inplace_binary_operation_function_call(
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
     value: Union[HandleBinding, Expression],
@@ -207,7 +260,7 @@ def _internal_inplace_binary_operation_function_call(
 
 def _trim_superfluous_fraction_digits(
     kind: str, var: QuantumSymbol, frac_digits_diff: int
-) -> Tuple[QuantumSymbol, List[VariableDeclarationStatement], List[BindOperation]]:
+) -> tuple[QuantumSymbol, list[VariableDeclarationStatement], list[BindOperation]]:
     if frac_digits_diff <= 0:
         return var, [], []
 
@@ -246,12 +299,12 @@ def _trim_superfluous_fraction_digits(
     return overlap_var, split_var_declarations, [bind_op]
 
 
-def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
+def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> tuple[
     QuantumSymbol,
-    List[VariableDeclarationStatement],
-    List[QuantumStatement],
-    List[QuantumFunctionCall],
-    List[BindOperation],
+    list[VariableDeclarationStatement],
+    list[QuantumStatement],
+    list[QuantumFunctionCall],
+    list[BindOperation],
 ]:
     quantum_type = var.quantum_type
     if TYPE_CHECKING:
@@ -291,7 +344,7 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
             [padding_rebind],
         )
 
-    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
+    significand_var, sign_var, sign_split_bind = _split_var(kind, var, 1)
     padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
 
     padding_rebind = BindOperation(
@@ -318,7 +371,7 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
 
 def _init_padding(
     sign_var: QuantumSymbol, padding_var: QuantumSymbol, size_diff: int
-) -> List[QuantumFunctionCall]:
+) -> list[QuantumFunctionCall]:
     padding_init_ops = [
         QuantumFunctionCall(
             function=CX.func_decl.name,
@@ -333,7 +386,7 @@ def _init_padding(
 
 def _allocate_padding(
     kind: str, size_diff: int
-) -> Tuple[QuantumSymbol, QuantumFunctionCall]:
+) -> tuple[QuantumSymbol, QuantumFunctionCall]:
     padding_var = QuantumSymbol(
         handle=HandleBinding(name=f"{kind}_sign_padding"),
         quantum_type=QuantumBitvector(
@@ -348,23 +401,95 @@ def _allocate_padding(
     return padding_var, padding_allocation
 
 
-def _split_sign(
-    kind: str, var: QuantumSymbol
-) -> Tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
-    significand_var = QuantumSymbol(
-        handle=HandleBinding(name=f"{kind}_significand"),
+def _split_var(
+    kind: str, var: QuantumSymbol, right_size: int
+) -> tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
+    left_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_left"),
         quantum_type=QuantumNumeric(
-            size=Expression(expr=str(var.quantum_type.size_in_bits - 1)),
+            size=Expression(expr=str(var.quantum_type.size_in_bits - right_size)),
             is_signed=Expression(expr="False"),
             fraction_digits=Expression(expr="0"),
         ),
     )
-    sign_var = QuantumSymbol(
-        handle=HandleBinding(name=f"{kind}_sign_bit"),
-        quantum_type=QuantumBit(),
+    right_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_right"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(right_size)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
     )
-    sign_split_bind = BindOperation(
+    split_bind = BindOperation(
         in_handles=[var.handle],
-        out_handles=[significand_var.handle, sign_var.handle],
+        out_handles=[left_var.handle, right_var.handle],
+    )
+    return left_var, right_var, split_bind
+
+
+def _split_and_xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> tuple[
+    Optional[QuantumSymbol],
+    Optional[QuantumSymbol],
+    list[VariableDeclarationStatement],
+    list[BindOperation],
+    list[Control],
+]:
+    if TYPE_CHECKING:
+        assert isinstance(value_var.quantum_type, QuantumNumeric)
+        assert isinstance(target_var.quantum_type, QuantumNumeric)
+    size_diff = (
+        value_var.quantum_type.size_in_bits - target_var.quantum_type.size_in_bits
+    )
+    if not value_var.quantum_type.sign_value or size_diff >= 0:
+        return target_var, value_var, [], [], []
+
+    if value_var.quantum_type.size_in_bits == 1:
+        return None, None, [], [], [_xor_sign(target_var, value_var)]
+
+    value_rest_var, value_sign_var, value_split_bind = _split_var("value", value_var, 1)
+    target_left_var, target_right_var, target_split_bind = _split_var(
+        "target", target_var, -size_diff + 1
+    )
+    var_decls = [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
+        )
+        for var in (value_rest_var, value_sign_var, target_left_var, target_right_var)
+    ]
+    bind_ops = [value_split_bind, target_split_bind]
+    sign_xor = _xor_sign(target_right_var, value_sign_var)
+    return target_left_var, value_rest_var, var_decls, bind_ops, [sign_xor]
+
+
+def _xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> Control:
+    quantum_type = value_var.quantum_type
+    if TYPE_CHECKING:
+        assert isinstance(quantum_type, QuantumNumeric)
+    if quantum_type.size_in_bits != 1 or quantum_type.fraction_digits_value not in (
+        0,
+        1,
+    ):
+        raise ClassiqInternalExpansionError
+
+    inner_xor = QuantumFunctionCall(
+        function=apply_to_all.func_decl.name,
+        positional_args=["X", target_var.handle],
+    )
+    inner_xor.set_func_decl(apply_to_all.func_decl)
+
+    if quantum_type.sign_value:
+        if quantum_type.fraction_digits_value == 1:
+            ctrl_value = -0.5
+        else:
+            ctrl_value = -1
+    else:
+        if quantum_type.fraction_digits_value == 1:
+            ctrl_value = 0.5
+        else:
+            ctrl_value = 1
+
+    return Control(
+        expression=Expression(expr=f"{value_var.handle} == {ctrl_value}"),
+        body=[inner_xor],
     )
-    return significand_var, sign_var, sign_split_bind

classiq/model_expansions/quantum_operations/phase.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Tuple
+from typing import TYPE_CHECKING
 
 import sympy
 from sympy import sympify
@@ -108,8 +108,8 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
 
 
 def _get_single_bit_vars_expression(
-    expr: sympy.Expr, vars_info: Dict[str, QuantumScalar]
-) -> Tuple[sympy.Expr, List[sympy.Symbol]]:
+    expr: sympy.Expr, vars_info: dict[str, QuantumScalar]
+) -> tuple[sympy.Expr, list[sympy.Symbol]]:
     bit_vars = []
     for var_name, var_info in vars_info.items():
         size = var_info.size_in_bits
@@ -139,9 +139,9 @@ def _get_single_bit_vars_expression(
 
 
 def _convert_ising_sympy_to_pauli_terms(
-    ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
+    ising_expr: sympy.Expr, ordered_sympy_vars: list[sympy.Symbol]
 ) -> str:
-    pauli_terms: List[str] = []
+    pauli_terms: list[str] = []
     coefficients = ising_expr.as_coefficients_dict(*ordered_sympy_vars)
     for expr_term in ising_expr.args:
         expr_vars = _get_vars(expr_term)
@@ -171,7 +171,7 @@ def _convert_ising_sympy_to_pauli_terms(
 
 def _convert_cost_expression_to_hamiltonian(
     expr: str,
-    vars: Dict[str, QuantumScalar],
+    vars: dict[str, QuantumScalar],
 ) -> Expression:
     sympy_expr = sympify(expr)
     single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -1,6 +1,5 @@
 import ast
 import re
-from typing import Tuple
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,6 +22,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -41,6 +41,10 @@ from classiq.model_expansions.visitors.boolean_expression_transformers import (
 from classiq.qmod import builtins
 from classiq.qmod.builtins.functions import X, allocate
 
+HANDLE_ERROR_MESSAGE = (
+    "Quantum variable '{handle_str}' cannot appear on both sides of the assignment"
+)
+
 
 def _is_constant(expr: str) -> bool:
     try:
@@ -129,7 +133,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression
-    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+    ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
             self._interpreter._is_frontend
             or op.operation_kind
@@ -150,7 +154,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _adapt_boolean_inplace(
         self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
-    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+    ) -> tuple[ArithmeticOperation, Expression, bool]:
         adapter = BooleanExpressionFuncLibAdapter(is_bool_opt)
         adapted_expression = self._evaluate_expression(
             Expression(expr=ast.unparse(adapter.visit(ast.parse(expression.expr))))
@@ -223,12 +227,28 @@ class QuantumAssignmentOperationEmitter(
         self._interpreter.emit_statement(allocate_call)
         return True
 
+    @staticmethod
+    def _get_updated_op_split_symbols(
+        op: QuantumAssignmentOperation,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> QuantumAssignmentOperation:
+        if op.result_var not in symbol_mapping:
+            return op
+        handle_str, quantum_type = symbol_mapping[op.result_var]
+        if handle_str in op.expression.expr:
+            raise ClassiqExpansionError(
+                HANDLE_ERROR_MESSAGE.format(handle_str=str(op.result_var))
+            )
+        new_result_handle = HandleBinding(name=handle_str)
+        return op.model_copy(
+            update=dict(result_var=new_result_handle, _result_type=quantum_type)
+        )
+
 
 def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
     if qe.result_var in qe.var_handles:
         raise ClassiqExpansionError(
-            f"Quantum variable {qe.result_var.name} cannot appear on both sides of "
-            f"the ^= assignment"
+            HANDLE_ERROR_MESSAGE.format(handle_str=str(qe.result_var))
         )
 
 

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,15 +1,54 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
+from classiq.model_expansions.call_to_model_converter import (
+    BlockFunctionInfo,
+    CallToModelConverter,
+)
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.qmod.semantics.error_manager import ErrorManager
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
 
 class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
+    def __init__(self, interpreter: "Interpreter") -> None:
+        super().__init__(interpreter)
+        self._model = self._interpreter._model
+        self._synthesized_separately_blocks = (
+            self._interpreter._synthesized_separately_blocks
+        )
+
     def emit(self, call: QuantumFunctionCall, /) -> None:
-        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
+        function: FunctionClosure = self._interpreter.evaluate(call.function).as_type(
+            FunctionClosure
+        )
         args = call.positional_args
         with ErrorManager().call(
             function.name
         ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
-            self._emit_quantum_function_call(function, args)
+            new_call = self._emit_quantum_function_call(function, args)
+            if function.synthesis_data.should_synthesize_separately:
+                interpreted_call_converter = CallToModelConverter(
+                    call,
+                    function.positional_arg_declarations,
+                    function.scope.data,
+                    self._model,
+                )
+                self._update_synthesized_separately_models(
+                    interpreted_call_converter, new_call.func_name
+                )
+
+    def _update_synthesized_separately_models(
+        self, call_converter: CallToModelConverter, call_name: str
+    ) -> None:
+        synthesized_separately_blocks = self._synthesized_separately_blocks
+        block_id = call_converter.block_id
+        block_function = synthesized_separately_blocks.get(block_id)
+        if block_function is None:
+            block_function = BlockFunctionInfo.from_call_converter(call_converter)
+            synthesized_separately_blocks[block_id] = block_function
+        block_function.calls.add(call_name)

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,5 +1,3 @@
-from typing import Type
-
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -24,7 +22,7 @@ class RepeatEmitter(Emitter[Repeat]):
                 self._emit_propagated(repeat, i)
 
     def _emit_propagated(self, repeat: Repeat, i: int) -> None:
-        closure_constructor: Type[FunctionClosure]
+        closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
             closure_constructor = GenerativeFunctionClosure

classiq/model_expansions/scope.py

@@ -1,9 +1,10 @@
 import itertools
 from collections import UserDict
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -104,7 +105,7 @@ class QuantumSymbol:
         )
 
     @property
-    def fields(self) -> Dict[str, "QuantumSymbol"]:
+    def fields(self) -> dict[str, "QuantumSymbol"]:
         quantum_type = self.quantum_type
         if not isinstance(quantum_type, TypeName):
             raise ClassiqExpansionError(
@@ -120,18 +121,18 @@ class QuantumSymbol:
 
 
 @singledispatch
-def _evaluated_to_str(value: Any) -> str:
+def evaluated_to_str(value: Any) -> str:
     return str(value)
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_list(value: list) -> str:
-    return f"[{', '.join(_evaluated_to_str(x) for x in value)}]"
+    return f"[{', '.join(evaluated_to_str(x) for x in value)}]"
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
-    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={_evaluated_to_str(v)}' for k, v in value.fields.items())})"
+    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
 @dataclass(frozen=True)
@@ -139,7 +140,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["Closure"] = None
 
-    def as_type(self, t: Type[T]) -> T:
+    def as_type(self, t: type[T]) -> T:
         if t is int:
             return self._as_int()  # type: ignore[return-value]
 
@@ -162,7 +163,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
         if isinstance(self.value, QuantumSymbol):
             return self.value.emit()
 
-        ret = Expression(expr=_evaluated_to_str(self.value))
+        ret = Expression(expr=evaluated_to_str(self.value))
         ret._evaluated_expr = EvaluatedExpression(value=self.value)
         return ret
 
@@ -176,7 +177,7 @@ else:
 class Scope(EvaluatedUserDict):
     def __init__(
         self,
-        data: Optional[Dict[str, Evaluated]] = None,
+        data: Optional[dict[str, Evaluated]] = None,
         /,
         *,
         parent: Optional["Scope"] = None,

classiq/model_expansions/scope_initialization.py

@@ -1,4 +1,4 @@
-from typing import List, Sequence
+from collections.abc import Sequence
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
@@ -43,7 +43,7 @@ def get_main_renamer(
     return ExpressionRenamer(var_mapping={})
 
 
-def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
+def _add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
         scope[constant.name] = Evaluated(
             value=evaluate_classical_expression(constant.value, scope).value
@@ -51,7 +51,7 @@ def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
 
 
 def _add_functions_to_scope(
-    functions: List[NativeFunctionDefinition], scope: Scope
+    functions: list[NativeFunctionDefinition], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.name] = Evaluated(
@@ -60,12 +60,13 @@ def _add_functions_to_scope(
                 positional_arg_declarations=function.positional_arg_declarations,
                 body=function.body,
                 scope=Scope(parent=scope),
+                synthesis_data=function.synthesis_data,
             )
         )
 
 
 def _add_generative_functions_to_scope(
-    functions: List[GenerativeQFunc], scope: Scope
+    functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.func_decl.name] = Evaluated(
@@ -138,7 +139,7 @@ def add_entry_point_params_to_scope(
 
 
 def init_top_level_scope(
-    model: Model, generative_functions: List[GenerativeQFunc], scope: Scope
+    model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     _add_functions_to_scope(model.functions, scope)
     _add_generative_functions_to_scope(generative_functions, scope)

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Dict, Type, cast
+from typing import TYPE_CHECKING, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 
@@ -18,29 +18,29 @@ def translate_to_sympy(expr: str) -> str:
 
 
 class ExpressionSympyTranslator(ast.NodeTransformer):
-    BINARY_OPERATORS: Dict[Type[ast.AST], str] = {
+    BINARY_OPERATORS: dict[type[ast.AST], str] = {
         ast.BitOr: "BitwiseOr",
         ast.BitAnd: "BitwiseAnd",
         ast.BitXor: "BitwiseXor",
         ast.Div: "do_div",
     }
 
-    UNARY_OPERATORS: Dict[Type[ast.AST], str] = {
+    UNARY_OPERATORS: dict[type[ast.AST], str] = {
         ast.Invert: "BitwiseNot",
         ast.Not: "Not",
     }
 
-    BOOLEAN_OPERATORS: Dict[Type[ast.AST], str] = {
+    BOOLEAN_OPERATORS: dict[type[ast.AST], str] = {
         ast.Or: "Or",
         ast.And: "And",
     }
 
-    COMPARE_OPERATORS: Dict[Type[ast.AST], str] = {
+    COMPARE_OPERATORS: dict[type[ast.AST], str] = {
         ast.Eq: "Eq",
         ast.NotEq: "Ne",
     }
 
-    SPECIAL_FUNCTIONS: Dict[str, str] = {
+    SPECIAL_FUNCTIONS: dict[str, str] = {
         "max": "Max",
         "min": "Min",
     }

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Any, Dict, Optional, get_args
+from typing import Any, Optional, get_args
 
 from sympy import (
     Array,
@@ -22,7 +22,7 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
 
 def sympy_to_python(
-    value: Any, locals: Optional[Dict[str, ExpressionValue]] = None
+    value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
     if isinstance(value, Integer):
         value = int(value)

classiq/model_expansions/visitors/variable_references.py

@@ -1,6 +1,7 @@
 import ast
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Dict, Iterator, List, Optional, Union
+from typing import Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,12 +24,12 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(self, ignore_duplicated_handles: bool = False) -> None:
-        self._var_handles: Dict[HandleBinding, bool] = {}
+        self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
         self._is_nested = False
 
     @property
-    def var_handles(self) -> List[HandleBinding]:
+    def var_handles(self) -> list[HandleBinding]:
         return list(self._var_handles)
 
     def visit(self, node: ast.AST) -> Union[
@@ -110,7 +111,7 @@ class VarRefCollector(ast.NodeVisitor):
 
 
 class VarRefTransformer(ast.NodeTransformer):
-    def __init__(self, var_mapping: Dict[str, str]) -> None:
+    def __init__(self, var_mapping: dict[str, str]) -> None:
         self.var_mapping = var_mapping
 
     def visit_Name(self, node: ast.Name) -> ast.Name: