classiq 0.93.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

classiq/interface/model/parameter.py

@@ -1,11 +1,9 @@
-from typing import Optional
-
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
 
 
 class Parameter(ASTNode):
-    name: Optional[str]
+    name: str | None
 
     def get_name(self) -> str:
         if self.name is None:

classiq/interface/model/port_declaration.py

@@ -49,7 +49,7 @@ class AnonPortDeclaration(Parameter):
     def qmod_type_name(self) -> str:
         prefix = ""
         suffix = ""
-        if self.type_modifier in (TypeModifier.Const, TypeModifier.Permutable):
+        if self.type_modifier is TypeModifier.Const:
             prefix += f"{self.type_modifier.name}["
             suffix += "]"
         if self.direction != PortDeclarationDirection.Inout:

classiq/interface/model/power.py

@@ -20,3 +20,7 @@ class Power(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.power]
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -1,6 +1,5 @@
 import abc
 from collections.abc import Mapping
-from typing import Optional
 
 import pydantic
 
@@ -55,7 +54,7 @@ class QuantumAssignmentOperation(QuantumExpressionOperation):
     result_var: ConcreteHandleBinding = pydantic.Field(
         description="The variable storing the expression result"
     )
-    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+    _result_type: QuantumType | None = pydantic.PrivateAttr(
         default=None,
     )
 

classiq/interface/model/quantum_function_call.py

@@ -2,7 +2,6 @@ from collections.abc import Iterable, Mapping, Sequence
 from itertools import chain
 from typing import (
     Literal,
-    Optional,
     Union,
 )
 
@@ -41,14 +40,12 @@ ArgValue = Union[
 class QuantumFunctionCall(QuantumOperation):
     kind: Literal["QuantumFunctionCall"]
 
-    function: Union[str, OperandIdentifier] = pydantic.Field(
+    function: str | OperandIdentifier = pydantic.Field(
         description="The function that is called"
     )
     positional_args: list[ArgValue] = pydantic.Field(default_factory=list)
 
-    _func_decl: Optional[QuantumFunctionDeclaration] = pydantic.PrivateAttr(
-        default=None
-    )
+    _func_decl: QuantumFunctionDeclaration | None = pydantic.PrivateAttr(default=None)
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["positional_args"])
@@ -60,7 +57,7 @@ class QuantumFunctionCall(QuantumOperation):
 
         return self._func_decl
 
-    def set_func_decl(self, fd: Optional[QuantumFunctionDeclaration]) -> None:
+    def set_func_decl(self, fd: QuantumFunctionDeclaration | None) -> None:
         if fd is not None and not isinstance(fd, QuantumFunctionDeclaration):
             raise ClassiqValueError(
                 "the declaration of a quantum function call cannot be set to a non-quantum function declaration."

classiq/interface/model/quantum_function_declaration.py

@@ -61,6 +61,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
     positional_arg_declarations: Sequence[AnonPositionalArg] = pydantic.Field(
         default_factory=list
     )
+    permutation: bool = pydantic.Field(default=False)
 
     @property
     def port_declarations(self) -> Sequence[AnonPortDeclaration]:

classiq/interface/model/quantum_lambda_function.py

@@ -1,11 +1,11 @@
-from typing import TYPE_CHECKING, Callable, Optional, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Union
 
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
 )
@@ -28,7 +28,7 @@ class QuantumLambdaFunction(ASTNode):
         description="A list of function calls passed to the operator"
     )
 
-    _func_decl: Optional[AnonQuantumOperandDeclaration] = pydantic.PrivateAttr(
+    _func_decl: AnonQuantumOperandDeclaration | None = pydantic.PrivateAttr(
         default=None
     )
 
@@ -57,7 +57,7 @@ class QuantumLambdaFunction(ASTNode):
     def named_func_decl(self) -> AnonQuantumOperandDeclaration:
         named_params = [
             param.rename(rename)
-            for param, rename in zip_strict(
+            for param, rename in zip(
                 self.func_decl.positional_arg_declarations,
                 self.pos_rename_params,
                 strict=False,  # strict=False enables lambda keyword args

classiq/interface/model/quantum_statement.py

@@ -1,6 +1,6 @@
-from collections.abc import Iterable, Mapping, Sequence
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Callable, Optional
+from typing import TYPE_CHECKING, Any
 from uuid import UUID, uuid4
 
 import pydantic
@@ -17,6 +17,9 @@ from classiq.interface.model.handle_binding import (
     HandleBinding,
 )
 
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
 
 class QuantumStatement(ASTNode):
     kind: str
@@ -27,7 +30,7 @@ class QuantumStatement(ASTNode):
     def model_copy(
         self,
         *,
-        update: Optional[Mapping[str, Any]] = None,
+        update: Mapping[str, Any] | None = None,
         deep: bool = False,
         keep_uuid: bool = False,
     ) -> Self:
@@ -45,11 +48,15 @@ class QuantumStatement(ASTNode):
     def expressions(self) -> list[Expression]:
         return []
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {}
+
 
 @dataclass
 class HandleMetadata:
     handle: HandleBinding
-    readable_location: Optional[str] = None
+    readable_location: str | None = None
 
 
 class QuantumOperation(QuantumStatement):

classiq/interface/model/quantum_type.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
 from pydantic import BaseModel, Field
@@ -23,7 +23,7 @@ if TYPE_CHECKING:
 
 
 class QuantumType(HashableASTNode):
-    _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
+    _size_in_bits: int | None = pydantic.PrivateAttr(default=None)
 
     def _update_size_in_bits_from_declaration(self) -> None:
         pass
@@ -96,11 +96,11 @@ class QuantumScalar(QuantumType):
     def fraction_digits_value(self) -> int:
         raise NotImplementedError
 
-    def get_bounds(self) -> Optional[tuple[float, float]]:
+    def get_bounds(self) -> tuple[float, float] | None:
         return None
 
     def get_effective_bounds(
-        self, machine_precision: Optional[int] = None
+        self, machine_precision: int | None = None
     ) -> tuple[float, float]:
         raise NotImplementedError
 
@@ -162,7 +162,7 @@ class QuantumBit(QuantumScalar):
         return 0
 
     def get_effective_bounds(
-        self, machine_precision: Optional[int] = None
+        self, machine_precision: int | None = None
     ) -> tuple[float, float]:
         return (0, 1)
 
@@ -176,7 +176,7 @@ class QuantumBitvector(QuantumType):
         discriminator="kind", default_factory=QuantumBit
     )
     kind: Literal["qvec"]
-    length: Optional[Expression] = Field(default=None)
+    length: Expression | None = Field(default=None)
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -278,11 +278,11 @@ class QuantumBitvector(QuantumType):
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
 
-    size: Optional[Expression] = pydantic.Field(default=None)
-    is_signed: Optional[Expression] = pydantic.Field(default=None)
-    fraction_digits: Optional[Expression] = pydantic.Field(default=None)
+    size: Expression | None = pydantic.Field(default=None)
+    is_signed: Expression | None = pydantic.Field(default=None)
+    fraction_digits: Expression | None = pydantic.Field(default=None)
 
-    _bounds: Optional[PydanticFloatTuple] = pydantic.PrivateAttr(default=None)
+    _bounds: PydanticFloatTuple | None = pydantic.PrivateAttr(default=None)
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -429,10 +429,10 @@ class QuantumNumeric(QuantumScalar):
             exprs.append(self.fraction_digits)
         return exprs
 
-    def get_bounds(self) -> Optional[tuple[float, float]]:
+    def get_bounds(self) -> tuple[float, float] | None:
         return self._bounds
 
-    def set_bounds(self, bounds: Optional[tuple[float, float]]) -> None:
+    def set_bounds(self, bounds: tuple[float, float] | None) -> None:
         self._bounds = bounds
 
     def reset_bounds(self) -> None:
@@ -446,7 +446,7 @@ class QuantumNumeric(QuantumScalar):
         )
 
     def get_effective_bounds(
-        self, machine_precision: Optional[int] = None
+        self, machine_precision: int | None = None
     ) -> tuple[float, float]:
         bounds = self.get_bounds() or self.get_maximal_bounds()
 
@@ -522,7 +522,7 @@ UNRESOLVED_SIZE = 1000
 def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
     signed: bool = False
     fraction_places: int = 0
-    bounds: Optional[tuple[float, float]] = None
+    bounds: tuple[float, float] | None = None
     if isinstance(qtype, QuantumNumeric):
         signed = qtype.sign_value
         fraction_places = qtype.fraction_digits_value

classiq/interface/model/repeat.py

@@ -21,3 +21,7 @@ class Repeat(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.count]
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/skip_control.py

@@ -9,3 +9,7 @@ if TYPE_CHECKING:
 class SkipControl(QuantumOperation):
     kind: Literal["SkipControl"]
     body: "StatementBlock"
+
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"body": self.body}

classiq/interface/model/validation_handle.py

@@ -1,7 +1,6 @@
 import dataclasses
 from collections.abc import Mapping
 from enum import Enum
-from typing import Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.handle_binding import HandleBinding
@@ -27,8 +26,8 @@ class ValidationHandle:
 
     def __init__(
         self,
-        initial_state: Optional[HandleState] = None,
-        errors: Optional[list[str]] = None,
+        initial_state: HandleState | None = None,
+        errors: list[str] | None = None,
     ) -> None:
         if initial_state is None and not errors:
             raise ClassiqError("Missing initial state for ValidationHandle")

classiq/interface/model/variable_declaration_statement.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import pydantic
 
@@ -15,7 +15,7 @@ class VariableDeclarationStatement(QuantumStatement):
     kind: Literal["VariableDeclarationStatement"]
 
     name: str
-    quantum_type: Optional[ConcreteQuantumType] = None
+    quantum_type: ConcreteQuantumType | None = None
     qmod_type: ConcreteType
 
     @pydantic.model_validator(mode="before")

classiq/interface/model/within_apply_operation.py

@@ -16,6 +16,10 @@ class WithinApply(QuantumOperation):
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["compute", "action"])
 
+    @property
+    def blocks(self) -> dict[str, "StatementBlock"]:
+        return {"compute": self.compute, "action": self.action}
+
 
 class Compute(QuantumOperation):
     kind: Literal["Compute"]

classiq/interface/pretty_print/expression_to_qmod.py

@@ -1,8 +1,7 @@
 import ast
 import re
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Callable, Optional
 
 import numpy as np
 
@@ -47,7 +46,7 @@ class PrettyPrinterError(AssertionError):
 @dataclass
 class ASTToQMODCode:
     level: int
-    decimal_precision: Optional[int]
+    decimal_precision: int | None
     indent_seq: str = "  "
 
     @property
@@ -197,7 +196,7 @@ def _remove_redundant_parentheses(expr: str) -> str:
 def transform_expression(
     expr: str,
     level: int = 0,
-    decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
+    decimal_precision: int | None = DEFAULT_DECIMAL_PRECISION,
 ) -> str:
     return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
         ast.parse(expr)

classiq/interface/server/routes.py

@@ -1,11 +1,9 @@
 ANALYZER_PREFIX = "/analyzer"
-CHEMISTRY_PREFIX = "/chemistry"
 EXECUTION_PREFIX = "/execution"
 EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 
-IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 USER_BUDGETS_PREFIX = "/user_budgets"
 
 
@@ -62,9 +60,6 @@ ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 
-GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
-
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
@@ -74,17 +69,6 @@ QASM_TO_QMOD_FULL_PATH = CONVERSION_PREFIX + QASM_TO_QMOD_SUFFIX
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
 
-IQCC_INIT_AUTH_SUFFIX = "/init_auth"
-IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
-IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
-IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX
-IQCC_LIST_AUTH_SCOPES_SUFFIX = "/auth_scopes"
-IQCC_LIST_AUTH_SCOPES_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_SCOPES_SUFFIX
-IQCC_LIST_AUTH_METHODS_SUFFIX = "/auth_methods"
-IQCC_LIST_AUTH_METHODS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_METHODS_SUFFIX
-IQCC_LIST_AUTH_TARGETS_SUFFIX = "/auth_targets"
-IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
-
 USER_BUDGETS_SUFFIX = "/all"
 USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX
 USER_BUDGET_SET_LIMIT_SUFFIX = "/set_limit"

classiq/interface/source_reference.py

@@ -1,7 +1,6 @@
 import os
 import re
 from pathlib import Path
-from typing import Optional
 
 import pydantic
 
@@ -30,7 +29,7 @@ class SourceReference(HashablePydanticBaseModel):
     start_column: int
     end_line: int
     end_column: int
-    file_name: Optional[str] = pydantic.Field(default=None)
+    file_name: str | None = pydantic.Field(default=None)
 
     def __str__(self) -> str:
         return f"{self.file_string()}{self.ref_inside_file()}"
@@ -47,8 +46,8 @@ class SourceReference(HashablePydanticBaseModel):
 
 class SourceReferencedError(pydantic.BaseModel):
     error: str
-    source_ref: Optional[SourceReference] = None
-    function: Optional[str] = None
+    source_ref: SourceReference | None = None
+    function: str | None = None
 
     def __str__(self) -> str:
         source_referenced_error = (

classiq/model_expansions/arithmetic.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -23,7 +22,7 @@ class NumericAttributes:
         size: int,
         is_signed: bool,
         fraction_digits: int,
-        bounds: Optional[tuple[float, float]] = None,
+        bounds: tuple[float, float] | None = None,
         trim_bounds: bool = False,
     ) -> None:
         self.size = size
@@ -84,6 +83,11 @@ class NumericAttributes:
             trim_bounds=True,
         )
 
+    def get_constant(self) -> float | None:
+        if self.lb == self.ub:
+            return self.lb
+        return None
+
     @classmethod
     def from_bounds(
         cls,
@@ -108,7 +112,7 @@ class NumericAttributes:
     def from_constant(
         cls,
         value: float,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         if machine_precision is not None:
             value = number_utils.limit_fraction_places(value, machine_precision)
@@ -124,7 +128,7 @@ class NumericAttributes:
     def from_quantum_scalar(
         cls,
         quantum_type: QuantumScalar,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         return cls(
             size=quantum_type.size_in_bits,
@@ -137,7 +141,7 @@ class NumericAttributes:
     def from_register_arithmetic_info(
         cls,
         register: RegisterArithmeticInfo,
-        machine_precision: Optional[int] = None,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         return cls.from_quantum_scalar(
             quantum_type=register_info_to_quantum_type(register),
@@ -147,8 +151,8 @@ class NumericAttributes:
     @classmethod
     def from_type_or_constant(
         cls,
-        from_: Union[float, QuantumScalar, RegisterArithmeticInfo],
-        machine_precision: Optional[int] = None,
+        from_: float | QuantumScalar | RegisterArithmeticInfo,
+        machine_precision: int | None = None,
     ) -> "NumericAttributes":
         if isinstance(from_, QuantumScalar):
             return cls.from_quantum_scalar(from_, machine_precision)

classiq/model_expansions/arithmetic_compute_result_attrs.py

@@ -1,6 +1,5 @@
 import math
 from collections.abc import Sequence
-from typing import Union
 
 from classiq.interface.exceptions import ClassiqValueError
 
@@ -65,11 +64,20 @@ def compute_result_attrs_bitwise_and(
     if left.fraction_digits > 0 or right.fraction_digits > 0:
         raise ClassiqValueError("Bitwise AND is only defined for integers")
 
+    if left.is_signed and not right.is_signed:
+        size = right.size
+    elif not left.is_signed and right.is_signed:
+        size = left.size
+    elif not left.is_signed and not right.is_signed:
+        size = min(left.size, right.size)
+    else:
+        size = max(left.size, right.size)
+
     # we comply with python, which uses arbitrary precision, so a positive number can
     # always be represented by "0..." and a negative number by "1...", thus their
     # bitwise AND is always non-negative
     return NumericAttributes(
-        size=max(left.size, right.size),
+        size=size,
         is_signed=left.is_signed and right.is_signed,
         fraction_digits=0,
     )
@@ -153,20 +161,21 @@ def compute_result_attrs_multiply(
 
 def compute_result_attrs_power(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: NumericAttributes,
     machine_precision: int,
 ) -> NumericAttributes:
-    if not float(right).is_integer() or right <= 0:
+    right_val = right.get_constant()
+    if right_val is None or not float(right_val).is_integer() or right_val <= 0:
         raise ClassiqValueError("Power must be a positive integer")
-    right = int(right)
+    right_val = int(right_val)
 
     bounds: tuple[float, float]
-    if (right % 2 == 0) and (left.lb < 0 < left.ub):
-        bounds = (0, max(left.lb**right, left.ub**right))
+    if (right_val % 2 == 0) and (left.lb < 0 < left.ub):
+        bounds = (0, max(left.lb**right_val, left.ub**right_val))
     else:
-        extremal_values = (left.lb**right, left.ub**right)
+        extremal_values = (left.lb**right_val, left.ub**right_val)
         bounds = (min(extremal_values), max(extremal_values))
-    fraction_places = left.fraction_digits * right
+    fraction_places = left.fraction_digits * right_val
     return NumericAttributes.from_bounds(
         bounds[0], bounds[1], fraction_places, machine_precision, trim_bounds=True
     )
@@ -174,18 +183,19 @@ def compute_result_attrs_power(
 
 def compute_result_attrs_lshift(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: NumericAttributes,
     machine_precision: int,
 ) -> NumericAttributes:
-    if not float(right).is_integer() or right < 0:
+    right_val = right.get_constant()
+    if right_val is None or not float(right_val).is_integer() or right_val < 0:
         raise ClassiqValueError("Shift must be a non-negative integer")
-    right = int(right)
+    right_val = int(right_val)
 
     scale = 1 << left.fraction_digits
-    lb = (int(left.lb * scale) << right) / scale
-    ub = (int(left.ub * scale) << right) / scale
-    fraction_digits = max(left.fraction_digits - right, 0)
-    integer_digits = left.integer_digits + right
+    lb = (int(left.lb * scale) << right_val) / scale
+    ub = (int(left.ub * scale) << right_val) / scale
+    fraction_digits = max(left.fraction_digits - right_val, 0)
+    integer_digits = left.integer_digits + right_val
     return NumericAttributes(
         size=integer_digits + fraction_digits,
         is_signed=left.is_signed,
@@ -196,21 +206,22 @@ def compute_result_attrs_lshift(
 
 def compute_result_attrs_rshift(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: NumericAttributes,
     machine_precision: int,
 ) -> NumericAttributes:
-    if not float(right).is_integer() or right < 0:
+    right_val = right.get_constant()
+    if right_val is None or not float(right_val).is_integer() or right_val < 0:
         raise ClassiqValueError("Shift must be a non-negative integer")
-    right = int(right)
+    right_val = int(right_val)
 
     scale = 1 << left.fraction_digits
-    lb = (int(left.lb * scale) >> right) / scale
-    ub = (int(left.ub * scale) >> right) / scale
+    lb = (int(left.lb * scale) >> right_val) / scale
+    ub = (int(left.ub * scale) >> right_val) / scale
     fraction_digits = (
-        0 if (right >= left.size and not left.is_signed) else left.fraction_digits
+        0 if (right_val >= left.size and not left.is_signed) else left.fraction_digits
     )
     return NumericAttributes(
-        size=max(left.size - right, fraction_digits, 1),
+        size=max(left.size - right_val, fraction_digits, 1),
         is_signed=left.is_signed,
         fraction_digits=fraction_digits,
         bounds=(lb, ub),
@@ -219,19 +230,20 @@ def compute_result_attrs_rshift(
 
 def compute_result_attrs_modulo(
     left: NumericAttributes,
-    right: Union[int, float],
+    right: NumericAttributes,
     machine_precision: int,
 ) -> NumericAttributes:
-    if not float(right).is_integer() or right < 2:
+    right_val = right.get_constant()
+    if right_val is None or not float(right_val).is_integer() or right_val < 2:
         raise ClassiqValueError("Modulus must be a positive power of two")
-    right = int(right)
-    if right & (right - 1) != 0:
+    right_val = int(right_val)
+    if right_val & (right_val - 1) != 0:
         raise ClassiqValueError("Modulus must be a positive power of two")
 
     if left.fraction_digits > 0:
         raise ClassiqValueError("Modulo is supported for integers only")
 
-    size = int(math.log2(right))
+    size = int(math.log2(right_val))
     if not left.is_signed and size >= left.size:
         return left
 

classiq/model_expansions/capturing/captured_vars.py

@@ -1,8 +1,8 @@
 import ast
 import dataclasses
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable, Union, cast
+from typing import TYPE_CHECKING, cast
 
 from typing_extensions import Self
 
@@ -297,7 +297,7 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        source_direction: Union[PortDirection, bool],
+        source_direction: PortDirection | bool,
         target_direction: PortDirection,
         var_name: str,
     ) -> PortDirection:

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,5 +1,4 @@
 import re
-from typing import Optional
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
@@ -17,7 +16,7 @@ def mangle_captured_var_name(
     return f"{var_name}{CAPTURE_SUFFIX}{function_name}__{function_depth}"
 
 
-def _match_capture_pattern(name: str) -> Optional[re.Match[str]]:
+def _match_capture_pattern(name: str) -> re.Match[str] | None:
     return re.match(CAPTURE_PATTERN, name)