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

classiq/interface/generator/mcu.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import pydantic
 
@@ -44,10 +44,10 @@ class Mcu(FunctionParams):
         default=0, description="gam radian angle."
     )
 
-    num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
+    num_ctrl_qubits: pydantic.PositiveInt | None = pydantic.Field(
         default=None, description="The number of control qubits."
     )
-    ctrl_state: Optional[str] = pydantic.Field(
+    ctrl_state: str | None = pydantic.Field(
         default=None, description="string of the control state"
     )
 

classiq/interface/generator/mcx.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -20,7 +20,7 @@ class Mcx(FunctionParams):
     arguments: list[RegisterUserInput] = pydantic.Field(
         default_factory=list, description="registers describing the state (ordered)"
     )
-    num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
+    num_ctrl_qubits: pydantic.PositiveInt | None = pydantic.Field(
         description="number of control qubits",
         default=None,
     )
@@ -33,7 +33,7 @@ class Mcx(FunctionParams):
     def _validate_argument_names(
         cls, arguments: list[RegisterUserInput]
     ) -> list[RegisterUserInput]:
-        register_name_list: list[Optional[str]] = [arg.name for arg in arguments]
+        register_name_list: list[str | None] = [arg.name for arg in arguments]
         if None in register_name_list:
             raise ClassiqValueError("All registers must be named")
         if len(set(register_name_list)) != len(register_name_list):

classiq/interface/generator/model/constraints.py

@@ -1,11 +1,12 @@
+import warnings
 from collections import defaultdict
-from typing import Optional, Union
+from typing import TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
 UNCONSTRAINED = -1
@@ -19,6 +20,8 @@ class OptimizationParameter(StrEnum):
 
 OptimizationParameterType = Union[OptimizationParameter, TranspilerBasisGates]
 
+T = TypeVar("T")
+
 
 def optimization_parameter_type_from_string(param: str) -> OptimizationParameterType:
     for enum_ in (OptimizationParameter, TranspilerBasisGates):
@@ -53,14 +56,18 @@ class Constraints(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    max_width: Optional[pydantic.PositiveInt] = pydantic.Field(
+    max_width: pydantic.PositiveInt | None = pydantic.Field(
         default=None,
         description="Maximum number of qubits in generated quantum circuit",
     )
-    max_depth: Optional[pydantic.PositiveInt] = None
+    max_depth: pydantic.PositiveInt | None = pydantic.Field(
+        default=None,
+    )
 
     max_gate_count: dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
-        pydantic.Field(default_factory=lambda: defaultdict(int))
+        pydantic.Field(
+            default_factory=lambda: defaultdict(int),
+        )
     )
 
     optimization_parameter: OptimizationParameterType = pydantic.Field(
@@ -68,3 +75,25 @@ class Constraints(BaseModel):
         description="If set, the synthesis engine optimizes the solution"
         " according to that chosen parameter",
     )
+
+    @pydantic.field_validator("max_depth", mode="before")
+    @classmethod
+    def deprecate_max_depth(cls, value: T) -> T:
+        if value is not None:
+            warnings.warn(
+                "max_depth is deprecated and will no longer be supported starting on 2025-10-27 at the earliest.",
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+        return value
+
+    @pydantic.field_validator("max_gate_count", mode="before")
+    @classmethod
+    def deprecate_max_gate_count(cls, value: T) -> T:
+        if value:
+            warnings.warn(
+                "max_gate_count is deprecated and will no longer be supported starting on 2025-10-27 at the earliest.",
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+        return value

classiq/interface/generator/model/preferences/preferences.py

@@ -1,11 +1,11 @@
 from collections.abc import Sequence
 from enum import IntEnum
-from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
+from typing import TYPE_CHECKING, Annotated, Any, Optional, TypeAlias
 
 import pydantic
 from pydantic import Field
 from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
@@ -135,21 +135,15 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
             - If `backend_service_provider` is not valid.
     """
 
-    _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
-        default=None
-    )
+    _backend_preferences: BackendPreferences | None = pydantic.PrivateAttr(default=None)
     machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
-    backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
-        pydantic.Field(
-            default=None,
-            description="Provider company or cloud for the requested backend.",
-        )
+    backend_service_provider: Provider | ProviderVendor | str | None = pydantic.Field(
+        default=None,
+        description="Provider company or cloud for the requested backend.",
     )
-    backend_name: Optional[Union[PydanticBackendName, AllBackendsNameByVendor]] = (
-        pydantic.Field(
-            default=None, description="Name of the requested backend or target."
-        )
+    backend_name: PydanticBackendName | AllBackendsNameByVendor | None = pydantic.Field(
+        default=None, description="Name of the requested backend or target."
     )
     custom_hardware_settings: CustomHardwareSettings = pydantic.Field(
         default_factory=CustomHardwareSettings,
@@ -182,7 +176,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "declarations).",
     )
 
-    qasm3: Optional[bool] = pydantic.Field(
+    qasm3: bool | None = pydantic.Field(
         None,
         description="Output OpenQASM 3.0 instead of OpenQASM 2.0. Relevant only for "
         "the `qasm` and `transpiled_circuit.qasm` attributes of `GeneratedCircuit`.",
@@ -194,7 +188,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "transpiled circuit and its depth",
     )
 
-    solovay_kitaev_max_iterations: Optional[pydantic.PositiveInt] = pydantic.Field(
+    solovay_kitaev_max_iterations: pydantic.PositiveInt | None = pydantic.Field(
         None,
         description="Maximum iterations for the Solovay-Kitaev algorithm (if applied).",
     )
@@ -203,7 +197,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         default=300, description="Generation timeout in seconds"
     )
 
-    optimization_timeout_seconds: Optional[pydantic.PositiveInt] = pydantic.Field(
+    optimization_timeout_seconds: pydantic.PositiveInt | None = pydantic.Field(
         default=None,
         description="Optimization timeout in seconds, or None for no "
         "optimization timeout (will still timeout when the generation timeout is over)",
@@ -217,9 +211,9 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
     @classmethod
     def optimization_timeout_less_than_generation_timeout(
         cls,
-        optimization_timeout_seconds: Optional[pydantic.PositiveInt],
+        optimization_timeout_seconds: pydantic.PositiveInt | None,
         info: ValidationInfo,
-    ) -> Optional[pydantic.PositiveInt]:
+    ) -> pydantic.PositiveInt | None:
         generation_timeout_seconds = info.data.get("timeout_seconds")
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
@@ -256,7 +250,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
 
     @pydantic.field_validator("backend_name")
     @classmethod
-    def validate_backend_name(cls, backend_name: Optional[str]) -> Optional[str]:
+    def validate_backend_name(cls, backend_name: str | None) -> str | None:
         if backend_name is None:
             return backend_name
         return backend_name.rstrip()
@@ -270,7 +264,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         return self
 
     @property
-    def backend_preferences(self) -> Optional[BackendPreferences]:
+    def backend_preferences(self) -> BackendPreferences | None:
         """
         Returns the backend preferences. If the backend preferences are not provided, the function sets the backend preferences according to backend name and provider.
 

classiq/interface/generator/model/quantum_register.py

@@ -1,11 +1,8 @@
 import itertools
-import sys
 from collections.abc import Iterator
 from types import GenericAlias as TypesGenericAlias
 from typing import (  # type: ignore[attr-defined]
     Any,
-    Optional,
-    Union,
     _GenericAlias,
 )
 
@@ -31,7 +28,7 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
         return super().__call__(*args, **kwargs, **arith_info)
 
     def __eq__(self, other: Any) -> bool:
-        if sys.version_info >= (3, 9) and isinstance(other, TypesGenericAlias):
+        if isinstance(other, TypesGenericAlias):
             return (
                 self.__origin__ == other.__origin__ and self.__args__ == other.__args__
             )
@@ -39,23 +36,23 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
             return super().__eq__(other)
 
     @property
-    def role(self) -> Optional[RegisterRole]:
+    def role(self) -> RegisterRole | None:
         return getattr(self.__origin__, "role", None)
 
     @property
-    def size(self) -> Optional[int]:
+    def size(self) -> int | None:
         if self.integer_places is not None:
             return self.integer_places + (self.fraction_places or 0)
         return None
 
     @property
-    def integer_places(self) -> Optional[int]:
+    def integer_places(self) -> int | None:
         if len(self.__args__) in (1, 2) and isinstance(self.__args__[0], int):
             return self.__args__[0]
         return None
 
     @property
-    def fraction_places(self) -> Optional[int]:
+    def fraction_places(self) -> int | None:
         if len(self.__args__) == 2 and isinstance(self.__args__[1], int):
             return self.__args__[1]
         return None
@@ -96,11 +93,11 @@ class QReg:
         qreg._qubits = qubits
         return qreg
 
-    def __getitem__(self, key: Union[int, slice]) -> "QReg":
+    def __getitem__(self, key: int | slice) -> "QReg":
         state = self._qubits[key]
         return QReg._from_qubits(state if isinstance(state, list) else [state])
 
-    def __setitem__(self, key: Union[int, slice], value: "QReg") -> None:
+    def __setitem__(self, key: int | slice, value: "QReg") -> None:
         if isinstance(key, int) and len(value) != 1:
             raise ClassiqQRegError(
                 f"Size mismatch: value size {len(value)}, expected size 1"

classiq/interface/generator/noise_properties.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 from pydantic import BaseModel
 
@@ -7,9 +5,7 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class NoiseProperties(BaseModel):
-    measurement_bit_flip_probability: Optional[PydanticProbabilityFloat] = (
-        pydantic.Field(
-            default=None,
-            description="Probability of measuring the wrong value for each qubit.",
-        )
+    measurement_bit_flip_probability: PydanticProbabilityFloat | None = pydantic.Field(
+        default=None,
+        description="Probability of measuring the wrong value for each qubit.",
     )

classiq/interface/generator/parameters.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Union
 from classiq.interface.generator.complex_type import Complex
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 else:
     TypeAlias = Any
 

classiq/interface/generator/partitioned_register.py

@@ -1,7 +1,6 @@
 import itertools
 from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
@@ -72,7 +71,7 @@ class RegisterPartition:
     partitioned_register: PartitionedRegister
 
     # index == None means this is the partition containing the leftover qubits.
-    _index: Optional[int]
+    _index: int | None
 
     def __post_init__(self) -> None:
         num_partitions = len(self.partitioned_register.partitions)

classiq/interface/generator/preferences/qasm_to_qmod_params.py

@@ -5,8 +5,19 @@ from classiq.interface.enum_utils import StrEnum
 
 
 class QmodFormat(StrEnum):
+    """
+    Qmod code format.
+    """
+
     NATIVE = "native"
+    """
+    Native Qmod (`.qmod`).
+    """
+
     PYTHON = "python"
+    """
+    Python Qmod (`.py`).
+    """
 
 
 class QasmToQmodParams(BaseModel):

classiq/interface/generator/quantum_function_call.py

@@ -10,7 +10,6 @@ from collections.abc import Iterable, Mapping, Sequence
 from re import Match
 from typing import (
     Any,
-    Optional,
     Union,
 )
 from uuid import UUID, uuid4
@@ -145,19 +144,17 @@ class SynthesisQuantumFunctionCall(BaseModel):
     power: PydanticPowerType = pydantic.Field(
         default=1, description="Number of successive calls to the operation"
     )
-    name: PydanticNonEmptyString = pydantic.Field(  # type: ignore[assignment]
+    name: PydanticNonEmptyString = pydantic.Field(
         default=None,
         validate_default=True,
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
-    caller_parameters: Optional[list[str]] = pydantic.Field(default=None)
-    parameter_assignments: Optional[dict[str, ClassicalArg]] = pydantic.Field(
-        default=None
-    )
-    source_id: Optional[UUID] = pydantic.Field(default=None)
-    arithmetic_id: Optional[str] = pydantic.Field(default=None)
-    inverse_op_id: Optional[UUID] = pydantic.Field(default=None)
+    caller_parameters: list[str] | None = pydantic.Field(default=None)
+    parameter_assignments: dict[str, ClassicalArg] | None = pydantic.Field(default=None)
+    source_id: UUID | None = pydantic.Field(default=None)
+    arithmetic_id: str | None = pydantic.Field(default=None)
+    inverse_op_id: UUID | None = pydantic.Field(default=None)
 
     uuid: UUID = pydantic.Field(default_factory=uuid4)
 
@@ -222,7 +219,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
     @pydantic.field_validator("name", mode="before")
     @classmethod
-    def _create_name(cls, name: Optional[str], info: ValidationInfo) -> str:
+    def _create_name(cls, name: str | None, info: ValidationInfo) -> str:
         """
         generates a name to a user defined-functions as follows:
         <function_name>_<SUFFIX_MARKER>_<random_suffix>
@@ -400,7 +397,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
     @pydantic.field_validator("inputs", mode="before")
     @classmethod
     def _validate_inputs(cls, inputs: IOType, info: ValidationInfo) -> WireDict:
-        params: Optional[FunctionParams] = info.data.get("function_params")
+        params: FunctionParams | None = info.data.get("function_params")
         is_inverse: bool = info.data.get("is_inverse", False)
         strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
         control_states: list[ControlState] = info.data.get("control_states", list())
@@ -556,7 +553,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> tuple[list[str], list[str], list[str]]:
-        expression_matches: Iterable[Optional[Match]] = map(
+        expression_matches: Iterable[Match | None] = map(
             functools.partial(re.fullmatch, IO_REGEX), expressions
         )
 

classiq/interface/generator/quantum_program.py

@@ -2,10 +2,9 @@ import uuid
 import warnings
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Union
+from typing import TypeAlias
 
 import pydantic
-from typing_extensions import TypeAlias
 
 from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
@@ -28,9 +27,6 @@ from classiq.interface.generator.generated_circuit_data import (
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.generator.model.model import ExecutionModel
-from classiq.interface.generator.synthesis_metadata.synthesis_duration import (
-    SynthesisStepDurations,
-)
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.ide.visual_model import CircuitMetrics
 
@@ -60,22 +56,16 @@ def _get_formatted_utc_current_time() -> str:
 
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: Optional[InitialConditions] = pydantic.Field(default=None)
+    initial_values: InitialConditions | None = pydantic.Field(default=None)
     data: GeneratedCircuitData
     model: ExecutionModel
-    transpiled_circuit: Optional[TranspiledCircuitData] = pydantic.Field(default=None)
+    transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
-    synthesis_duration: Optional[SynthesisStepDurations] = pydantic.Field(default=None)
-    debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
-        default=None
-    )
-    compressed_debug_info: Optional[bytes] = pydantic.Field(default=None)
+    compressed_debug_info: bytes | None = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
-    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
-    synthesis_warnings: Optional[list[str]] = pydantic.Field(default=None)
+    execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
+    synthesis_warnings: list[str] | None = pydantic.Field(default=None)
     should_warn: bool = pydantic.Field(default=False)
-    # Unique identifier for the circuit (since the program_id might change when running show). Used for the circuit store.
-    circuit_id: str = pydantic.Field(default_factory=get_uuid_as_str)
 
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
@@ -95,8 +85,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def to_program(
         self,
-        initial_values: Optional[InitialConditions] = None,
-        instruction_set: Optional[QuantumInstructionSet] = None,
+        initial_values: InitialConditions | None = None,
+        instruction_set: QuantumInstructionSet | None = None,
     ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
         if instruction_set is not None:
@@ -141,7 +131,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             for name, init_value in initial_values.items()
         }
 
-    def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
+    def save_results(self, filename: str | Path | None = None) -> None:
         """
         Saves quantum program results as json into a file.
             Parameters:
@@ -171,10 +161,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             else self
         )
 
-    def get_debug_info(self) -> Optional[list[FunctionDebugInfoInterface]]:
-        # Support legacy uncompressed debug info
-        if self.debug_info is not None:
-            return self.debug_info
+    def get_debug_info(self) -> list[FunctionDebugInfoInterface] | None:
         if self.compressed_debug_info is None:
             return None
         decompressed_debug_info_dict_list = decompress(self.compressed_debug_info)

classiq/interface/generator/range_types.py

@@ -1,5 +1,5 @@
 import math
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -17,8 +17,8 @@ DEF_RTOL: float = 1e-05
 
 
 class Range(BaseModel, Generic[RangeType]):
-    lower_bound: Optional[RangeType] = None
-    upper_bound: Optional[RangeType] = None
+    lower_bound: RangeType | None = None
+    upper_bound: RangeType | None = None
     model_config = ConfigDict(frozen=True)
 
     @pydantic.model_validator(mode="after")

classiq/interface/generator/slice_parsing_utils.py

@@ -1,6 +1,5 @@
 import re
 from re import Match
-from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import NAME_REGEX
@@ -17,8 +16,8 @@ def parse_io_slicing(io_str: str) -> tuple[str, slice]:
     return name, get_slice(slicing)
 
 
-def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
-    match: Optional[Match] = re.fullmatch(IO_REGEX, io_str)
+def separate_name_and_slice(io_str: str) -> tuple[str, str | None]:
+    match: Match | None = re.fullmatch(IO_REGEX, io_str)
     if match is None:
         raise AssertionError("Input/output name validation error")
     name, slicing = (match.groupdict().get(x) for x in [NAME, SLICING])
@@ -27,7 +26,7 @@ def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
     return name, slicing
 
 
-def get_slice(slicing: Optional[str]) -> slice:
+def get_slice(slicing: str | None) -> slice:
     if slicing is None:
         return slice(None)
 
@@ -61,5 +60,5 @@ def get_slice(slicing: Optional[str]) -> slice:
         raise AssertionError("Input/output slicing validation error")
 
 
-def _int_or_none(v: str) -> Optional[int]:
+def _int_or_none(v: str) -> int | None:
     return int(v) if v else None

classiq/interface/generator/standard_gates/standard_gates.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import pydantic
 
@@ -38,9 +38,7 @@ class _StandardGate(FunctionParams, metaclass=MyMetaAngledClassModel):  # type:
     def num_target_qubits(self) -> int:
         return self._num_target_qubits
 
-    def __init_subclass__(
-        cls, angles: Optional[list[str]] = None, **kwargs: Any
-    ) -> None:
+    def __init_subclass__(cls, angles: list[str] | None = None, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
 

classiq/interface/generator/synthesis_execution_parameter.py

@@ -1,6 +1,4 @@
-from typing import Union
-
-from typing_extensions import TypeAlias
+from typing import TypeAlias, Union
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
 

classiq/interface/generator/synthesis_metadata/synthesis_duration.py

@@ -17,3 +17,12 @@ class SynthesisStepDurations(pydantic.BaseModel):
                 self.postprocessing,
             )
         )
+
+    def __repr__(self) -> str:
+        return (
+            f"Preprocessing: {self.preprocessing:.2f}s, "
+            f"Solving: {self.solving:.2f}s, "
+            f"Conversion to Circuit: {self.conversion_to_circuit:.2f}s, "
+            f"Postprocessing: {self.postprocessing:.2f}s, "
+            f"Total: {self.total_time():.2f}s"
+        )

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,5 +1,4 @@
 from itertools import chain
-from typing import Optional
 
 import pydantic
 import sympy
@@ -10,10 +9,10 @@ from classiq.interface.generator.parameters import ParameterType
 
 
 class FunctionExecutionData(pydantic.BaseModel):
-    power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
+    power_parameter: ParameterType | None = pydantic.Field(default=None)
 
     @property
-    def power_vars(self) -> Optional[list[str]]:
+    def power_vars(self) -> list[str] | None:
         if self.power_parameter is None:
             return None
         return list(map(str, sympy.sympify(self.power_parameter).free_symbols))

classiq/interface/generator/transpiler_basis_gates.py

@@ -1,11 +1,16 @@
-from typing import TYPE_CHECKING, Optional
-
-from typing_extensions import TypeAlias
+from typing import TYPE_CHECKING, TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 
 BasisGates: TypeAlias = frozenset[str]
 
+NATIVE_GATES_TO_CLASSIQ_GATES_MAP: dict[str, str] = {
+    "cnot": "cx",
+    "toffoli": "ccx",
+    "p": "rz",
+    "i": "id",
+}
+
 SINGLE_QUBIT_GATES: BasisGates = frozenset(
     (
         "u1",
@@ -66,6 +71,9 @@ DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = (
     SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
 )
+ALL_NON_3_QBIT_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")
@@ -80,7 +88,7 @@ ALL_GATES_DICT = {gate.upper(): gate.lower() for gate in sorted(ALL_GATES)}
 
 class LowerValsEnum(StrEnum):
     @classmethod
-    def _missing_(cls, value: Optional[str]) -> Optional[str]:  # type: ignore[override]
+    def _missing_(cls, value: str | None) -> str | None:  # type: ignore[override]
         if not isinstance(value, str):
             return None
         lower = value.lower()