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

classiq/applications/qnn/torch_utils.py

@@ -1,6 +1,5 @@
 from collections.abc import Sized
 from functools import reduce
-from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -52,8 +51,8 @@ def _result_to_tensor(
     all_results: list,
     inputs: Tensor,
     weights: Tensor,
-    expected_shape: Optional[Shape] = None,
-    requires_grad: Optional[bool] = None,
+    expected_shape: Shape | None = None,
+    requires_grad: bool | None = None,
 ) -> Tensor:
     default_shape = (
         torch.Size([inputs.shape[0]])
@@ -94,7 +93,7 @@ def iter_inputs_weights(
     post_process: PostProcessFunction,
     *,
     expected_shape: Shape = (),
-    requires_grad: Optional[bool] = None,
+    requires_grad: bool | None = None,
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))

classiq/applications/qnn/types.py

@@ -1,4 +1,5 @@
-from typing import Callable, Union
+from collections.abc import Callable
+from typing import Union
 
 import torch
 from torch import Tensor

classiq/applications/qsp/qsp.py

@@ -1,10 +1,9 @@
 import builtins
 import importlib.util
+from collections.abc import Callable
 from functools import wraps
-from typing import Callable, Optional
 
 import numpy as np
-from matplotlib import pyplot as plt
 from numpy.polynomial import Chebyshev, Polynomial
 from numpy.polynomial.chebyshev import cheb2poly, poly2cheb
 
@@ -122,6 +121,8 @@ def _plot_qsp_approx(
     f_target: Callable[[np.ndarray], np.ndarray],
     interval: tuple[float, float] = (-1, 1),
 ) -> None:
+    from matplotlib import pyplot as plt
+
     grid_full = np.linspace(-1, 1, 3000)
     grid_interval = np.linspace(interval[0], interval[1], 3000)
 
@@ -154,10 +155,10 @@ def _plot_qsp_approx(
 def qsp_approximate(
     f_target: Callable[[np.ndarray], np.ndarray],
     degree: int,
-    parity: Optional[int] = None,
+    parity: int | None = None,
     interval: tuple[float, float] = (-1, 1),
     bound: float = 0.99,
-    num_grid_points: Optional[int] = None,
+    num_grid_points: int | None = None,
     plot: bool = False,
 ) -> tuple[np.ndarray, float]:
     """

classiq/applications/qsvm/qsvm_data_generation.py

@@ -1,6 +1,5 @@
 import logging
 from collections import defaultdict
-from typing import Optional
 
 import numpy as np
 
@@ -14,7 +13,7 @@ def generate_data(
     range_min: float = 0,
     range_max: float = 2 * np.pi,
     std: float = 0.5,
-    sources: Optional[np.ndarray] = None,
+    sources: np.ndarray | None = None,
 ) -> dict[int, np.ndarray]:
     if sources is None:
         sources = np.random.uniform(

classiq/evaluators/classical_expression.py

@@ -17,9 +17,6 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
 from classiq.interface.generator.functions.classical_type import ClassicalArray, Integer
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
-    QmodExpressionBwc,
-)
 from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
     evaluate_qmod_expression,
 )
@@ -59,7 +56,6 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
     if expr.is_evaluated():
         return Evaluated(value=expr.value.value)
     expr_ast = ast.parse(expr.expr)
-    expr_ast = QmodExpressionBwc().visit(expr_ast)
     expr_val = evaluate_qmod_expression(
         ast.unparse(expr_ast),
         classical_struct_declarations=list(QMODULE.type_decls.values()),

classiq/evaluators/parameter_types.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, NoReturn, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, Union
 
 import sympy
 
@@ -25,7 +25,6 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -80,7 +79,7 @@ def evaluate_parameter_types_from_args(
             f"{len(arguments)} were given"
         )
 
-    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+    for parameter, argument in zip(parameters, arguments, strict=True):
         if isinstance(parameter, ClassicalParameterDeclaration):
             arg_val = argument.value
             if not isinstance(arg_val, QmodAnnotatedExpression):
@@ -88,11 +87,11 @@ def evaluate_parameter_types_from_args(
 
     evaluated_params = [
         _evaluate_type_from_arg(parameter, argument, closure)
-        for parameter, argument in zip_strict(parameters, arguments, strict=True)
+        for parameter, argument in zip(parameters, arguments, strict=True)
     ]
 
     parameter_names = {parameter.name for parameter in parameters}
-    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+    for parameter, argument in zip(parameters, arguments, strict=True):
         if isinstance(parameter, QuantumOperandDeclaration):
             _update_operand_signature_environment(
                 argument.value, parameter_names, closure
@@ -271,9 +270,9 @@ def _evaluate_op_type_from_arg(
 
 def _raise_argument_type_error(
     arg_val: Any,
-    arg_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    arg_type: QmodType | AnonQuantumOperandDeclaration,
     param_name: str,
-    param_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    param_type: QmodType | AnonQuantumOperandDeclaration,
 ) -> NoReturn:
     raise ClassiqExpansionError(
         f"Argument {str(arg_val)!r} of type "
@@ -378,7 +377,7 @@ def _eval_expr(
     if expected_type is int and isinstance(val, float) and int(val) == val:
         val = int(val)
 
-    failing_type: Optional[str] = None
+    failing_type: str | None = None
     if isinstance(val, QmodAnnotatedExpression):
         val_type = val.get_type(val.root)
         if not isinstance(val_type, expected_qmod_type):

classiq/evaluators/qmod_annotated_expression.py

@@ -2,7 +2,7 @@ import ast
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Union, cast
+from typing import Any, cast
 
 import sympy
 
@@ -98,26 +98,24 @@ class QmodAnnotatedExpression:
     def get_node(self, node_id: QmodExprNodeId) -> ast.AST:
         return self._node_mapping[node_id]
 
-    def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+    def set_value(self, node: ast.AST | QmodExprNodeId, value: Any) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         self._values[node] = value
 
-    def get_value(self, node: Union[ast.AST, QmodExprNodeId]) -> Any:
+    def get_value(self, node: ast.AST | QmodExprNodeId) -> Any:
         if isinstance(node, ast.AST):
             node = id(node)
         return self._values[node]
 
-    def has_value(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_value(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._values
 
-    def set_type(
-        self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
-    ) -> None:
+    def set_type(self, node: ast.AST | QmodExprNodeId, qmod_type: QmodType) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
@@ -126,12 +124,12 @@ class QmodAnnotatedExpression:
             node = id(node)
         self._types[node] = qmod_type
 
-    def get_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QmodType:
+    def get_type(self, node: ast.AST | QmodExprNodeId) -> QmodType:
         if isinstance(node, ast.AST):
             node = id(node)
         return self._types[node]
 
-    def get_quantum_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QuantumType:
+    def get_quantum_type(self, node: ast.AST | QmodExprNodeId) -> QuantumType:
         if isinstance(node, ast.AST):
             node = id(node)
         qmod_type = self._types[node]
@@ -139,7 +137,7 @@ class QmodAnnotatedExpression:
             raise ClassiqInternalExpansionError
         return cast(QuantumType, qmod_type)
 
-    def get_classical_type(self, node: Union[ast.AST, QmodExprNodeId]) -> ClassicalType:
+    def get_classical_type(self, node: ast.AST | QmodExprNodeId) -> ClassicalType:
         if isinstance(node, ast.AST):
             node = id(node)
         qmod_type = self._types[node]
@@ -147,7 +145,7 @@ class QmodAnnotatedExpression:
             raise ClassiqInternalExpansionError
         return cast(ClassicalType, qmod_type)
 
-    def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+    def set_var(self, node: ast.AST | QmodExprNodeId, var: HandleBinding) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         var = var.collapse()
@@ -158,25 +156,25 @@ class QmodAnnotatedExpression:
         else:
             self._quantum_vars[node] = var
 
-    def get_var(self, node: Union[ast.AST, QmodExprNodeId]) -> HandleBinding:
+    def get_var(self, node: ast.AST | QmodExprNodeId) -> HandleBinding:
         if isinstance(node, ast.AST):
             node = id(node)
         return (self._classical_vars | self._quantum_vars)[node]
 
-    def has_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         return self.has_classical_var(node) or self.has_quantum_var(node)
 
-    def has_classical_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_classical_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._classical_vars
 
-    def has_quantum_var(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_var(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_vars
 
-    def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+    def remove_var(self, node: ast.AST | QmodExprNodeId) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
@@ -188,9 +186,9 @@ class QmodAnnotatedExpression:
 
     def set_quantum_subscript(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
-        value: Union[ast.AST, QmodExprNodeId],
-        index: Union[ast.AST, QmodExprNodeId],
+        node: ast.AST | QmodExprNodeId,
+        value: ast.AST | QmodExprNodeId,
+        index: ast.AST | QmodExprNodeId,
     ) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
@@ -204,7 +202,7 @@ class QmodAnnotatedExpression:
             value=value, index=index
         )
 
-    def has_quantum_subscript(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_subscript(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_subscripts
@@ -216,7 +214,7 @@ class QmodAnnotatedExpression:
 
     def set_quantum_type_attr(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
+        node: ast.AST | QmodExprNodeId,
         value: HandleBinding,
         attr: str,
     ) -> None:
@@ -228,7 +226,7 @@ class QmodAnnotatedExpression:
             value=value, attr=attr
         )
 
-    def has_quantum_type_attribute(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_quantum_type_attribute(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._quantum_type_attrs
@@ -240,8 +238,8 @@ class QmodAnnotatedExpression:
 
     def set_concatenation(
         self,
-        node: Union[ast.AST, QmodExprNodeId],
-        elements: Sequence[Union[ast.AST, QmodExprNodeId]],
+        node: ast.AST | QmodExprNodeId,
+        elements: Sequence[ast.AST | QmodExprNodeId],
     ) -> None:
         if self._locked:
             raise ClassiqInternalExpansionError("QAE is locked")
@@ -257,7 +255,7 @@ class QmodAnnotatedExpression:
                 inlined_elements.extend(self._concatenations.pop(element).elements)
         self._concatenations[node] = ConcatenationAnnotation(elements=inlined_elements)
 
-    def has_concatenation(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
+    def has_concatenation(self, node: ast.AST | QmodExprNodeId) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._concatenations
@@ -271,7 +269,7 @@ class QmodAnnotatedExpression:
     def get_quantum_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
 
-    def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+    def clear_node_data(self, node: ast.AST | QmodExprNodeId) -> None:
         if isinstance(node, ast.AST):
             node = id(node)
         self._node_mapping.pop(node, None)

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from enum import IntEnum
-from typing import Any, Callable, Optional, cast
+from typing import Any, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -79,13 +79,13 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         *,
         treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
-        classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
-        enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
-        classical_function_declarations: Optional[
+        classical_struct_declarations: Sequence[StructDeclaration] | None = None,
+        enum_declarations: Sequence[EnumDeclaration] | None = None,
+        classical_function_declarations: None | (
             Sequence[ClassicalFunctionDeclaration]
-        ] = None,
-        classical_function_callables: Optional[Mapping[str, Callable]] = None,
-        scope: Optional[Mapping[str, Any]] = None,
+        ) = None,
+        classical_function_callables: Mapping[str, Callable] | None = None,
+        scope: Mapping[str, Any] | None = None,
     ) -> None:
         self._expr_val = expr_val
         self._treat_qnum_as_float = treat_qnum_as_float
@@ -258,13 +258,13 @@ def evaluate_qmod_expression(
     *,
     treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
-    classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
-    enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
-    classical_function_declarations: Optional[
+    classical_struct_declarations: Sequence[StructDeclaration] | None = None,
+    enum_declarations: Sequence[EnumDeclaration] | None = None,
+    classical_function_declarations: None | (
         Sequence[ClassicalFunctionDeclaration]
-    ] = None,
-    classical_function_callables: Optional[Mapping[str, Callable]] = None,
-    scope: Optional[Mapping[str, Any]] = None,
+    ) = None,
+    classical_function_callables: Mapping[str, Callable] | None = None,
+    scope: Mapping[str, Any] | None = None,
 ) -> QmodAnnotatedExpression:
     expr_ast = ast.parse(expr, mode="eval").body
     expr_value = QmodAnnotatedExpression(expr_ast)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,5 +1,6 @@
 import ast
-from typing import Any, Callable, TypeVar, cast
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
 
 import sympy
 

classiq/evaluators/qmod_expression_visitors/sympy_wrappers.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from sympy import Function, Integer
 from sympy.logic.boolalg import BooleanFunction
@@ -6,7 +6,7 @@ from sympy.logic.boolalg import BooleanFunction
 
 class BitwiseAnd(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a & b
 
@@ -15,7 +15,7 @@ class BitwiseAnd(Function):
 
 class BitwiseXor(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a ^ b
 
@@ -24,7 +24,7 @@ class BitwiseXor(Function):
 
 class LogicalXor(BooleanFunction):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[bool]:
+    def eval(cls, a: Any, b: Any) -> bool | None:
         if isinstance(a, bool) and isinstance(b, bool):
             return a ^ b
 
@@ -33,7 +33,7 @@ class LogicalXor(BooleanFunction):
 
 class BitwiseOr(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a | b
 
@@ -42,7 +42,7 @@ class BitwiseOr(Function):
 
 class BitwiseNot(Function):
     @classmethod
-    def eval(cls, a: Any) -> Optional[int]:
+    def eval(cls, a: Any) -> int | None:
         if isinstance(a, Integer):
             return ~a
 
@@ -51,7 +51,7 @@ class BitwiseNot(Function):
 
 class RShift(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a >> b
 
@@ -60,7 +60,7 @@ class RShift(Function):
 
 class LShift(Function):
     @classmethod
-    def eval(cls, a: Any, b: Any) -> Optional[int]:
+    def eval(cls, a: Any, b: Any) -> int | None:
         if isinstance(a, Integer) and isinstance(b, Integer):
             return a << b
 

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -1,5 +1,6 @@
 import ast
-from typing import Callable, Union, cast
+from collections.abc import Callable
+from typing import cast
 
 import sympy
 
@@ -19,7 +20,6 @@ from classiq.interface.generator.functions.classical_type import (
     Real,
 )
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
@@ -39,7 +39,7 @@ INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
 
 
 def _check_classical_array_arg_type(
-    param_type: Union[ClassicalArray, ClassicalTuple], arg_type: ClassicalType
+    param_type: ClassicalArray | ClassicalTuple, arg_type: ClassicalType
 ) -> bool:
     if not isinstance(arg_type, (ClassicalArray, ClassicalTuple)):
         return False
@@ -63,7 +63,7 @@ def _check_classical_array_arg_type(
         )
     return all(
         check_classical_arg_type(param_element_type, arg_element_type)
-        for param_element_type, arg_element_type in zip_strict(
+        for param_element_type, arg_element_type in zip(
             param_type.element_types, arg_type.element_types, strict=True
         )
     )

classiq/evaluators/qmod_node_evaluators/list_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Optional, cast
+from typing import cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -57,7 +57,7 @@ def list_allowed(classical_types: list[ClassicalType]) -> bool:
     if len(classical_types) < 2:
         return True
 
-    element_without_empty_tuple: Optional[ClassicalType] = None
+    element_without_empty_tuple: ClassicalType | None = None
     for classical_type in classical_types:
         if not _has_empty_tuple(classical_type):
             element_without_empty_tuple = classical_type

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import sympy
 
@@ -22,7 +22,7 @@ def get_numeric_attrs(
     qmod_type: QmodType,
     machine_precision: int,
     treat_qnum_as_float: bool,
-) -> Optional[NumericAttributes]:
+) -> NumericAttributes | None:
     if isinstance(qmod_type, Bool):
         return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
     if is_classical_type(qmod_type):
@@ -45,7 +45,7 @@ def get_classical_value_for_arithmetic(
     node: ast.AST,
     qmod_type: QmodType,
     treat_qnum_as_float: bool,
-) -> Optional[float]:
+) -> float | None:
     if not is_classical_type(qmod_type):
         return None
     if not expr_val.has_value(node):

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Optional, cast
+from typing import cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -53,12 +53,12 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
                 f"Slice indices must be integers, not {index_type.raw_qmod_type_name}"
             )
 
-    start_val: Optional[int] = None
+    start_val: int | None = None
     if expr_val.has_value(start):
         start_val = cast(int, expr_val.get_value(start))
         if start_val < 0:
             raise ClassiqExpansionError("Slice indices must be positive integers")
-    stop_val: Optional[int] = None
+    stop_val: int | None = None
     if expr_val.has_value(stop):
         stop_val = cast(int, expr_val.get_value(stop))
         if start_val is not None and stop_val < start_val:
@@ -74,7 +74,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
             or (stop_val is not None and stop_val > subject_type.length_value)
         ):
             raise ClassiqExpansionError("Array index out of range")
-        length_expr: Optional[Expression] = None
+        length_expr: Expression | None = None
         if start_val is not None and stop_val is not None:
             length_expr = Expression(expr=str(stop_val - start_val))
         slice_type = ClassicalArray(
@@ -139,7 +139,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
             f"{index_type.raw_qmod_type_name}"
         )
 
-    sub_val: Optional[int] = None
+    sub_val: int | None = None
     if expr_val.has_value(subscript):
         sub_val = cast(int, expr_val.get_value(subscript))
         if sub_val < 0:
@@ -195,10 +195,10 @@ def eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> No
 
 
 def validate_quantum_subscript_index_properties(
-    index_size: Optional[int],
-    index_sign: Optional[bool],
-    index_fraction_digits: Optional[int],
-    array_len: Optional[int],
+    index_size: int | None,
+    index_sign: bool | None,
+    index_fraction_digits: int | None,
+    array_len: int | None,
 ) -> None:
     if index_sign or (index_fraction_digits is not None and index_fraction_digits > 0):
         raise ClassiqValueError("Quantum index must be an unsigned integer")

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, cast
+from typing import Union, cast
 
 import sympy
 
@@ -42,7 +42,7 @@ def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
 
 def get_numeric_properties(
     qmod_type: QuantumScalar,
-) -> tuple[Optional[int], Optional[bool], Optional[int]]:
+) -> tuple[int | None, bool | None, int | None]:
     if isinstance(qmod_type, QuantumBit):
         return 1, False, 0
     if not isinstance(qmod_type, QuantumNumeric):
@@ -66,7 +66,7 @@ def get_numeric_properties(
 
 
 def element_types(
-    classical_type: Union[ClassicalArray, ClassicalTuple],
+    classical_type: ClassicalArray | ClassicalTuple,
 ) -> list[ClassicalType]:
     if isinstance(classical_type, ClassicalArray):
         return [classical_type.element_type]
@@ -74,8 +74,8 @@ def element_types(
 
 
 def array_len(
-    classical_type: Union[ClassicalArray, ClassicalTuple],
-) -> Optional[int]:
+    classical_type: ClassicalArray | ClassicalTuple,
+) -> int | None:
     if isinstance(classical_type, ClassicalTuple):
         return len(classical_type.element_types)
     if classical_type.has_constant_length:
@@ -95,7 +95,7 @@ def is_classical_integer(qmod_type: QmodType) -> bool:
     )
 
 
-def get_sympy_val(val: sympy.Basic) -> Union[bool, int, float, complex]:
+def get_sympy_val(val: sympy.Basic) -> bool | int | float | complex:
     if hasattr(val, "is_Boolean") and val.is_Boolean:
         return bool(val)
     if (hasattr(val, "is_integer") and val.is_integer) or (