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

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith.argument_utils import (
@@ -16,7 +16,6 @@ from classiq.interface.generator.arith.binary_ops import (
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
-    CyclicShift,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -57,9 +56,9 @@ def get_params(
     node_id: str,
     args: list[RegisterOrFloat],
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     operation = id2op(node_id)
     if target and not operation_allows_target(operation):
@@ -78,9 +77,9 @@ def or_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return BitwiseOr(
         left_arg=left_arg,
@@ -94,9 +93,9 @@ def and_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return BitwiseAnd(
         left_arg=left_arg,
@@ -110,9 +109,9 @@ def xor_params_getter(
     left_arg: RegisterOrInt,
     right_arg: RegisterOrInt,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return BitwiseXor(
         left_arg=left_arg,
@@ -126,9 +125,9 @@ def xor_params_getter(
 def invert_params_getter(
     arg: RegisterOrInt,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return BitwiseInvert(
         arg=arg,
@@ -141,9 +140,9 @@ def invert_params_getter(
 def usub_params_getter(
     arg: RegisterOrInt,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Negation(
         arg=arg,
@@ -157,9 +156,9 @@ def adder_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Adder(
         left_arg=left_arg,
@@ -174,9 +173,9 @@ def multiplier_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Multiplier(
         left_arg=left_arg,
@@ -190,9 +189,9 @@ def power_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Power(
         left_arg=left_arg,
@@ -206,9 +205,9 @@ def min_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Min(
         left_arg=left_arg,
@@ -222,9 +221,9 @@ def max_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Max(
         left_arg=left_arg,
@@ -238,9 +237,9 @@ def sub_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Subtractor(
         left_arg=left_arg,
@@ -255,9 +254,9 @@ def equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Equal(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -268,9 +267,9 @@ def not_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return NotEqual(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -281,9 +280,9 @@ def greater_than_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return GreaterThan(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -294,9 +293,9 @@ def greater_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return GreaterEqual(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -307,9 +306,9 @@ def less_than_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return LessThan(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -320,9 +319,9 @@ def less_equal_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return LessEqual(
         left_arg=left_arg, right_arg=right_arg, machine_precision=machine_precision
@@ -332,9 +331,9 @@ def less_equal_params_getter(
 def logical_and_params_getter(
     *arg: list[RegisterOrFloat],
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return LogicalAnd(args=arg, target=target, machine_precision=machine_precision)
 
@@ -342,9 +341,9 @@ def logical_and_params_getter(
 def logical_or_params_getter(
     *arg: list[RegisterOrFloat],
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return LogicalOr(args=arg, target=target, machine_precision=machine_precision)
 
@@ -353,9 +352,9 @@ def lshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return LShift(
         left_arg=left_arg,
@@ -370,9 +369,9 @@ def rshift_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return RShift(
         left_arg=left_arg,
@@ -383,47 +382,13 @@ def rshift_params_getter(
     )
 
 
-def clshift_params_getter(
-    left_arg: RegisterArithmeticInfo,
-    right_arg: int,
-    machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
-) -> ArithmeticOperationParams:
-    return CyclicShift(
-        left_arg=left_arg,
-        right_arg=-right_arg,
-        machine_precision=machine_precision,
-        inplace_arg=inplace_arg,
-        output_size=output_size,
-    )
-
-
-def crshift_params_getter(
-    left_arg: RegisterArithmeticInfo,
-    right_arg: int,
-    machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
-) -> ArithmeticOperationParams:
-    return CyclicShift(
-        left_arg=left_arg,
-        right_arg=right_arg,
-        machine_precision=machine_precision,
-        inplace_arg=inplace_arg,
-        output_size=output_size,
-    )
-
-
 def modulo_params_getter(
     left_arg: RegisterArithmeticInfo,
     right_arg: int,
     machine_precision: int,
-    output_size: Optional[int] = None,
-    inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None,
+    output_size: int | None = None,
+    inplace_arg: str | None = None,
+    target: RegisterArithmeticInfo | None = None,
 ) -> ArithmeticOperationParams:
     return Modulo(
         left_arg=left_arg,
@@ -453,8 +418,6 @@ params_getter_map: dict[str, ParamsGetter] = dict(
     NotEq=not_equal_params_getter,
     RShift=rshift_params_getter,
     LShift=lshift_params_getter,
-    CRShift=crshift_params_getter,
-    CLShift=clshift_params_getter,
     Mod=modulo_params_getter,
     min=min_params_getter,
     max=max_params_getter,

classiq/interface/generator/arith/arithmetic_result_builder.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import networkx as nx
 
@@ -27,7 +27,7 @@ class ArithmeticResultBuilder:
 
     @staticmethod
     def convert_result_definition(
-        node: Any, definition: Optional[RegisterOrConst], machine_precision: int
+        node: Any, definition: RegisterOrConst | None, machine_precision: int
     ) -> RegisterOrConst:
         if definition:
             return definition
@@ -61,7 +61,7 @@ class ArithmeticResultBuilder:
         graph: nx.DiGraph,
         result_definitions: ArithmeticDefinitions,
         machine_precision: int,
-    ) -> tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+    ) -> tuple[RegisterArithmeticInfo, RegisterArithmeticInfo | None]:
         inputs_node_set: set[str] = {
             vertex for vertex, deg in graph.in_degree if deg == 0
         }
@@ -95,7 +95,7 @@ class ArithmeticResultBuilder:
         node: str,
         *,
         machine_precision: int,
-    ) -> tuple[RegisterArithmeticInfo, Optional[RegisterArithmeticInfo]]:
+    ) -> tuple[RegisterArithmeticInfo, RegisterArithmeticInfo | None]:
         node_params = arithmetic_param_getters.get_params(
             node_id=node,
             args=args,

classiq/interface/generator/arith/ast_node_rewrite.py

@@ -1,7 +1,7 @@
 import ast
 import itertools
 from collections.abc import Iterator
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 from classiq.interface.exceptions import ClassiqArithmeticError
 
@@ -25,13 +25,17 @@ class AstNodeRewrite(ast.NodeTransformer):
         new_node.id = self.extract_node_id(new_node)
         return new_node
 
-    def extract_node_id(self, node: ast.AST) -> Optional[Union[str, float]]:
+    def extract_node_id(self, node: ast.AST) -> str | float | None:
         if hasattr(node, "id"):
             return node.id
         elif hasattr(node, "op"):
             return type(node.op).__name__ + next(self.count_str_gen)
-        elif hasattr(node, "func"):
-            return self.extract_node_id(node.func)
+        elif (
+            hasattr(node, "func")
+            and hasattr(node.func, "id")
+            and isinstance(node.func.id, str)
+        ):
+            return node.func.id + next(self.count_str_gen)
         elif hasattr(node, "value"):
             return node.value
         elif hasattr(node, "ops"):

classiq/interface/generator/arith/binary_ops.py

@@ -5,7 +5,6 @@ from typing import (
     ClassVar,
     Generic,
     Literal,
-    Optional,
     TypeVar,
     Union,
 )
@@ -120,7 +119,7 @@ class BinaryOpParams(
 class InplacableBinaryOpParams(
     BinaryOpParams[LeftDataT, RightDataT], Generic[LeftDataT, RightDataT]
 ):
-    inplace_arg: Optional[ArgToInplace] = None
+    inplace_arg: ArgToInplace | None = None
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -128,7 +127,7 @@ class InplacableBinaryOpParams(
         if isinstance(values, dict):
             left_arg = values.get("left_arg")
             right_arg = values.get("right_arg")
-            inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
+            inplace_arg: ArgToInplace | None = values.get("inplace_arg")
             if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
                 raise ClassiqValueError(
                     _NumericArgumentInplaceErrorMessage.format(right_arg)
@@ -179,7 +178,7 @@ class InplacableBinaryOpParams(
             0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
         )
 
-    def _carried_arguments(self) -> tuple[Optional[LeftDataT], Optional[RightDataT]]:
+    def _carried_arguments(self) -> tuple[LeftDataT | None, RightDataT | None]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
             self.left_arg, RegisterArithmeticInfo
         ):
@@ -611,7 +610,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
 
     def _get_inner_action_garbage_size(
         self,
-        action_type: Union[type["Power"], type[Multiplier]],
+        action_type: type["Power"] | type[Multiplier],
         *,
         arg: RegisterArithmeticInfo,
         action_right_arg: RegisterOrConst,
@@ -662,7 +661,7 @@ class EffectiveUnaryOpParams(
 
 class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     output_name = "left_shifted"
-    inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
+    inplace_arg: ArgToInplace | None = ArgToInplace.LEFT
 
     @pydantic.model_validator(mode="after")
     def _validate_legal_modulo(self) -> Self:
@@ -703,7 +702,7 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
 
 class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     output_name = "right_shifted"
-    inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
+    inplace_arg: ArgToInplace | None = ArgToInplace.LEFT
 
     @staticmethod
     def _shifted_fraction_places(*, arg: RegisterArithmeticInfo, shift: int) -> int:
@@ -751,37 +750,9 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         )
 
 
-class CyclicShift(EffectiveUnaryOpParams[int]):
-    output_name = "cyclic_shifted"
-    inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
-
-    @pydantic.model_validator(mode="after")
-    def _validate_legal_modulo(self) -> Self:
-        output_size = self.output_size
-        if output_size is None:
-            return self
-        arg = self.left_arg
-        if not isinstance(arg, RegisterArithmeticInfo):
-            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
-        assert arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return self
-
-    def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        if self.inplace_arg is None:
-            return 0
-        return max(0, self.left_arg.size - self.result_register.size)
-
-    def _get_result_register(self) -> RegisterArithmeticInfo:
-        return RegisterArithmeticInfo(
-            size=self.output_size or self.left_arg.size,
-            is_signed=self._include_sign and self.left_arg.is_signed,
-            fraction_places=self.left_arg.fraction_places,
-        )
-
-
 class Modulo(EffectiveUnaryOpParams[int]):
     output_name = "modulus"
-    inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
+    inplace_arg: ArgToInplace | None = ArgToInplace.LEFT
 
     @pydantic.field_validator("left_arg", mode="before")
     @classmethod

classiq/interface/generator/arith/logical_ops.py

@@ -1,5 +1,4 @@
 from collections.abc import Iterable
-from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict
@@ -19,7 +18,7 @@ def get_arg_name(idx: int) -> str:
 
 class LogicalOps(ArithmeticOperationParams):
     args: list[RegisterOrConst]
-    target: Optional[RegisterArithmeticInfo]
+    target: RegisterArithmeticInfo | None
     _should_invert_node_list: list[str] = pydantic.PrivateAttr(default_factory=list)
 
     def update_should_invert_node_list(self, invert_args: list[str]) -> None:
@@ -27,7 +26,7 @@ class LogicalOps(ArithmeticOperationParams):
 
     @pydantic.field_validator("output_size")
     @classmethod
-    def _validate_output_size(cls, output_size: Optional[int]) -> int:
+    def _validate_output_size(cls, output_size: int | None) -> int:
         if output_size is not None and output_size != 1:
             raise ClassiqValueError("logical operation output size must be 1")
         return 1

classiq/interface/generator/arith/number_utils.py

@@ -1,4 +1,4 @@
-from typing import Final, Union
+from typing import Final
 
 MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
@@ -25,7 +25,7 @@ def binary_to_float(
 
 def binary_to_float_or_int(
     bin_rep: str, fraction_part_size: int = 0, is_signed: bool = False
-) -> Union[float, int]:
+) -> float | int:
     if fraction_part_size == 0:
         return binary_to_int(bin_rep, is_signed)
     return binary_to_float(bin_rep, fraction_part_size, is_signed)

classiq/interface/generator/arith/register_user_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from pydantic import ConfigDict
@@ -51,7 +51,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     @pydantic.field_validator("bounds", mode="before")
     @classmethod
     def _validate_bounds(
-        cls, bounds: Optional[PydanticFloatTuple], info: ValidationInfo
+        cls, bounds: PydanticFloatTuple | None, info: ValidationInfo
     ) -> PydanticFloatTuple:
         size = info.data.get("size")
         is_signed = info.data.get("is_signed", False)

classiq/interface/generator/arith/unary_ops.py

@@ -1,5 +1,5 @@
 from collections.abc import Iterable
-from typing import Final, Optional
+from typing import Final
 
 import pydantic
 from pydantic import ConfigDict
@@ -127,7 +127,7 @@ class Sign(UnaryOpParams):
     @pydantic.field_validator("output_size")
     @classmethod
     def _validate_output_size(
-        cls, output_size: Optional[pydantic.PositiveInt]
+        cls, output_size: pydantic.PositiveInt | None
     ) -> pydantic.PositiveInt:
         if output_size is not None and output_size != 1:
             raise ClassiqValueError("Sign output size must be 1")

classiq/interface/generator/circuit_code/circuit_code.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.exceptions import ClassiqMissingOutputFormatError
@@ -26,31 +24,31 @@ class CircuitCodeInterface(pydantic.BaseModel):
         return {key: LongStr(value) for key, value in outputs.items()}
 
     @property
-    def qasm(self) -> Optional[Code]:
+    def qasm(self) -> Code | None:
         return self.outputs.get(QuantumFormat.QASM)
 
     @property
-    def qsharp(self) -> Optional[Code]:
+    def qsharp(self) -> Code | None:
         return self.outputs.get(QuantumFormat.QSHARP)
 
     @property
-    def qir(self) -> Optional[Code]:
+    def qir(self) -> Code | None:
         return self.outputs.get(QuantumFormat.QIR)
 
     @property
-    def ionq(self) -> Optional[Code]:
+    def ionq(self) -> Code | None:
         return self.outputs.get(QuantumFormat.IONQ)
 
     @property
-    def cirq_json(self) -> Optional[Code]:
+    def cirq_json(self) -> Code | None:
         return self.outputs.get(QuantumFormat.CIRQ_JSON)
 
     @property
-    def qasm_cirq_compatible(self) -> Optional[Code]:
+    def qasm_cirq_compatible(self) -> Code | None:
         return self.outputs.get(QuantumFormat.QASM_CIRQ_COMPATIBLE)
 
     @property
-    def _execution_serialization(self) -> Optional[Code]:
+    def _execution_serialization(self) -> Code | None:
         return self.outputs.get(QuantumFormat.EXECUTION_SERIALIZATION)
 
     def get_code(self, instruction_set: QuantumInstructionSet) -> Code:
@@ -60,7 +58,7 @@ class CircuitCodeInterface(pydantic.BaseModel):
             raise ClassiqMissingOutputFormatError(missing_formats=[quantum_format])
         return code
 
-    def get_code_by_priority(self) -> Optional[CodeAndSyntax]:
+    def get_code_by_priority(self) -> CodeAndSyntax | None:
         for instruction_set, quantum_format in INSTRUCTION_SET_TO_FORMAT.items():
             code = self.outputs.get(quantum_format)
             if code is not None:

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -1,4 +1,4 @@
-from typing_extensions import TypeAlias
+from typing import TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet

classiq/interface/generator/complex_type.py

@@ -1,10 +1,10 @@
-from typing import Annotated, Union
+from typing import Annotated
 
 from pydantic import PlainSerializer, PlainValidator
 from pydantic.json_schema import WithJsonSchema
 
 
-def validate_complex(v: Union[complex, str]) -> complex:
+def validate_complex(v: complex | str) -> complex:
     if isinstance(v, str):
         v = "".join(v.split())
     return complex(v)

classiq/interface/generator/copy.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.generator.arith import argument_utils
@@ -10,7 +8,7 @@ from classiq.interface.generator.function_params import FunctionParams
 class Copy(FunctionParams):
     source: argument_utils.RegisterOrConst
     target: RegisterArithmeticInfo
-    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+    output_size: pydantic.PositiveInt | None = pydantic.Field(default=None)
 
     @property
     def source_size(self) -> int: