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

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:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,12 +1,7 @@
 SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
 CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
-    "hypercube_entangler_graph",
-    "grid_entangler_graph",
     "qft_const_adder_phase",
-    "molecule_problem_to_hamiltonian",
-    "fock_hamiltonian_problem_to_hamiltonian",
-    "molecule_ground_state_solution_post_process",
 }
 
 CLASSIQ_EXPR_FUNCTIONS = {

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,10 +1,9 @@
 import re
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, get_args
 
 from sympy import Expr
-from typing_extensions import get_args
 
 from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
 from classiq.interface.exceptions import ClassiqValueError
@@ -21,7 +20,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self, constant_type: Optional[type] = None) -> bool:
+    def is_constant(self, constant_type: type | None = None) -> bool:
         return isinstance(
             self.value,
             get_args(RuntimeConstant) if constant_type is None else constant_type,

classiq/interface/generator/expressions/expression.py

@@ -1,6 +1,6 @@
 import ast
 from collections.abc import Mapping
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
@@ -24,7 +24,7 @@ from classiq.interface.generator.function_params import validate_expression_str
 
 class Expression(HashableASTNode):
     expr: str
-    _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
+    _evaluated_expr: EvaluatedExpression | None = PrivateAttr(default=None)
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -1,9 +1,8 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeGuard
 
 import sympy
 from sympy import Integer
-from typing_extensions import TypeGuard
 
 from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
@@ -24,7 +23,7 @@ if TYPE_CHECKING:
     )
 
 
-def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
+def _is_int(val: Any) -> TypeGuard[int | sympy.Basic]:
     if isinstance(val, sympy.Basic):
         return val.is_Number
     return isinstance(val, int)
@@ -47,7 +46,7 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
         raise NotImplementedError
 
     def __getitem__(
-        self, key: Union[slice, int, Integer, ClassicalProxy]
+        self, key: slice | int | Integer | ClassicalProxy
     ) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
@@ -68,9 +67,7 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
     def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:
         raise NotImplementedError
 
-    def _get_subscript(
-        self, index_: Union[int, Integer, ClassicalProxy]
-    ) -> ClassicalProxy:
+    def _get_subscript(self, index_: int | Integer | ClassicalProxy) -> ClassicalProxy:
         if _is_int(index_):
             index = int(index_)
             if index < 0:

classiq/interface/generator/function_param_list.py

@@ -7,7 +7,6 @@ from classiq.interface.generator.arith.binary_ops import (
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
-    CyclicShift,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -28,61 +27,32 @@ from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
 from classiq.interface.generator.copy import Copy
-from classiq.interface.generator.entangler_params import (
-    GridEntangler,
-    HypercubeEntangler,
-    TwoDimensionalEntangler,
-)
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
 from classiq.interface.generator.hadamard_transform import HadamardTransform
 from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
     Exponentiation,
 )
-from classiq.interface.generator.hamiltonian_evolution.qdrift import QDrift
 from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (
     SuzukiTrotter,
 )
 from classiq.interface.generator.hardware_efficient_ansatz import (
     HardwareEfficientAnsatz,
 )
-from classiq.interface.generator.hartree_fock import HartreeFock
-from classiq.interface.generator.hva import HVA
 from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
-from classiq.interface.generator.qft import QFT
-from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
 from classiq.interface.generator.reset import Reset
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
     standard_gate_function_param_library,
 )
 from classiq.interface.generator.standard_gates.u_gate import UGate
-from classiq.interface.generator.state_preparation import (
-    BellStatePreparation,
-    ComputationalBasisStatePreparation,
-    ExponentialStatePreparation,
-    GHZStatePreparation,
-    StatePreparation,
-    UniformDistributionStatePreparation,
-    WStatePreparation,
-)
-from classiq.interface.generator.ucc import UCC
 from classiq.interface.generator.unitary_gate import UnitaryGate
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
 function_param_library: FunctionParamLibrary = FunctionParamLibrary(
     param_list=itertools.chain(
         {
-            StatePreparation,
-            ComputationalBasisStatePreparation,
-            UniformDistributionStatePreparation,
-            BellStatePreparation,
-            GHZStatePreparation,
-            WStatePreparation,
-            ExponentialStatePreparation,
-            QFT,
             BitwiseAnd,
             BitwiseOr,
             BitwiseXor,
@@ -102,33 +72,23 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             Subtractor,
             RShift,
             LShift,
-            CyclicShift,
             Modulo,
-            TwoDimensionalEntangler,
-            HypercubeEntangler,
-            GridEntangler,
             Mcx,
             Mcu,
             CustomFunction,
             HardwareEfficientAnsatz,
             UnitaryGate,
-            LinearPauliRotations,
             Multiplier,
             Power,
-            HartreeFock,
-            UCC,
             Min,
             Max,
             Exponentiation,
             CommutingPauliExponentiation,
             SuzukiTrotter,
-            QDrift,
             Identity,
             RandomizedBenchmarking,
-            HVA,
             UGate,
             AmplitudeLoading,
-            QSVMFeatureMap,
             HadamardTransform,
             Copy,
             Reset,

classiq/interface/generator/function_params.py

@@ -5,7 +5,6 @@ from collections.abc import Collection, Iterable, Mapping
 from typing import (
     Annotated,
     Any,
-    Optional,
     Union,
     get_args,
 )
@@ -108,7 +107,7 @@ GenerationExpressionSupportedNodeTypes = Union[
 
 
 def validate_expression_str(
-    expr_str: str, supported_functions: Optional[set[str]] = None
+    expr_str: str, supported_functions: set[str] | None = None
 ) -> None:
     # By default, no functions are allowed.
     supported_functions = supported_functions or set()
@@ -219,7 +218,7 @@ class FunctionParams(HashablePydanticBaseModel):
             and (len(output_names - input_names) <= 1)
         )
 
-    def get_power_order(self) -> Optional[int]:
+    def get_power_order(self) -> int | None:
         return None
 
     def _create_ios(self) -> None:
@@ -227,7 +226,7 @@ class FunctionParams(HashablePydanticBaseModel):
 
     @staticmethod
     def _get_size_of_ios(
-        registers: Collection[Optional[RegisterArithmeticInfo]],
+        registers: Collection[RegisterArithmeticInfo | None],
     ) -> int:
         return sum(reg.size if reg is not None else 0 for reg in registers)
 
@@ -265,11 +264,11 @@ class FunctionParams(HashablePydanticBaseModel):
 def parse_function_params(
     *,
     params: Any,
-    discriminator: Optional[Any],
+    discriminator: Any | None,
     param_classes: Collection[type[FunctionParams]],
     no_discriminator_error: Exception,
     bad_function_error: Exception,
-    default_parser_class: Optional[type[FunctionParams]] = None,
+    default_parser_class: type[FunctionParams] | None = None,
 ) -> FunctionParams:  # Any is for use in pydantic validators.
     if not discriminator:
         raise no_discriminator_error

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 import pydantic
 
@@ -23,7 +23,7 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         default_factory=list,
     )
 
-    return_type: Optional[ConcreteClassicalType] = pydantic.Field(
+    return_type: ConcreteClassicalType | None = pydantic.Field(
         description="The type of the classical value that is returned by the function (for classical functions)",
         default=None,
     )

classiq/interface/generator/functions/classical_type.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
 from pydantic import PrivateAttr
@@ -131,7 +131,7 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    length: Optional[Expression] = None
+    length: Expression | None = None
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -160,7 +160,7 @@ class ClassicalArray(ClassicalType):
         return self.length.to_int_value()
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        length: Optional[ExpressionValue]
+        length: ExpressionValue | None
         if self.length is None:
             length = None
         elif not self.length.is_evaluated():

classiq/interface/generator/functions/type_modifier.py

@@ -1,22 +1,7 @@
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
 class TypeModifier(StrEnum):
     Const = "const"
-    Permutable = "permutable"
     Mutable = "mutable"
     Inferred = "inferred"
-
-    @staticmethod
-    def and_(first: "TypeModifier", second: "TypeModifier") -> "TypeModifier":
-        if second is TypeModifier.Inferred:
-            raise ClassiqInternalExpansionError
-        if first is TypeModifier.Mutable or second is TypeModifier.Mutable:
-            return TypeModifier.Mutable
-        elif first is TypeModifier.Permutable or second is TypeModifier.Permutable:
-            return TypeModifier.Permutable
-        else:
-            if first is not TypeModifier.Const and second is not TypeModifier.Const:
-                raise ClassiqInternalExpansionError("Unexpected type modifiers")
-            return TypeModifier.Const

classiq/interface/generator/functions/type_name.py

@@ -35,8 +35,8 @@ if TYPE_CHECKING:
 class TypeName(ClassicalType, QuantumType):
     kind: Literal["struct_instance"]
     name: str = pydantic.Field(description="The type name of the instance")
-    _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
-        pydantic.PrivateAttr(default=None)
+    _assigned_fields: Mapping[str, "ConcreteQuantumType"] | None = pydantic.PrivateAttr(
+        default=None
     )
     _classical_struct_decl: Optional["StructDeclaration"] = pydantic.PrivateAttr(
         default=None

classiq/interface/generator/generated_circuit_data.py

@@ -1,11 +1,10 @@
 import logging
 import re
-from typing import Literal, Optional, Union
+from typing import Literal, TypeAlias
 from uuid import UUID
 
 import pydantic
 from pydantic import ConfigDict, Field
-from typing_extensions import TypeAlias
 
 from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
@@ -87,12 +86,12 @@ class GeneratedFunction(pydantic.BaseModel):
     name: str
     control_states: list[ControlState]
     registers: list[GeneratedRegister] = list()
-    depth: Optional[int] = pydantic.Field(default=None)
-    width: Optional[int] = pydantic.Field(default=None)
+    depth: int | None = pydantic.Field(default=None)
+    width: int | None = pydantic.Field(default=None)
     dangling_inputs: dict[str, GeneratedRegister] = dict()
     dangling_outputs: dict[str, GeneratedRegister] = dict()
 
-    def __getitem__(self, key: Union[int, str]) -> GeneratedRegister:
+    def __getitem__(self, key: int | str) -> GeneratedRegister:
         if isinstance(key, int):
             return self.registers[key]
         if isinstance(key, str):
@@ -101,7 +100,7 @@ class GeneratedFunction(pydantic.BaseModel):
                     return register
         raise KeyError(key)
 
-    def get(self, key: Union[int, str]) -> Optional[GeneratedRegister]:
+    def get(self, key: int | str) -> GeneratedRegister | None:
         try:
             return self.__getitem__(key)
         except KeyError:
@@ -119,7 +118,7 @@ class GeneratedCircuitData(pydantic.BaseModel):
     width: int
     circuit_parameters: list[ParameterName] = pydantic.Field(default_factory=list)
     qubit_mapping: QubitMapping = pydantic.Field(default_factory=QubitMapping)
-    execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
+    execution_data: ExecutionData | None = pydantic.Field(default=None)
 
     @classmethod
     def from_empty_logic_flow(cls) -> "GeneratedCircuitData":
@@ -176,21 +175,20 @@ STATEMENTS_NAME: dict[str, StatementType] = {
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction] = Field(default=None)
+    generated_function: GeneratedFunction | None = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
-    absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
-    control_variable: Optional[str] = Field(default=None)
-    is_basis_gate: Optional[bool] = Field(default=None)
+    absolute_qubits: tuple[int, ...] | None = Field(default=None)
+    control_variable: str | None = Field(default=None)
+    is_basis_gate: bool | None = Field(default=None)
     is_inverse: bool = Field(default=False)
+    is_daggered: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
-    uuid: Optional[UUID] = Field(default=None, exclude=True)
+    uuid: UUID | None = Field(default=None, exclude=True)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
     back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
-    # Temporary field to store the override debug info for parallel old/new visualization
-    override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
     def is_allocate_or_free(self) -> bool:
@@ -229,7 +227,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return f"{name}{suffix}"
 
     @property
-    def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
+    def first_back_ref(self) -> ConcreteQuantumStatement | None:
         return self.back_refs[0] if self.back_refs else None
 
     @property
@@ -318,9 +316,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         )
 
     def inverse(self) -> "FunctionDebugInfoInterface":
-        if self.override_debug_info is not None:
-            self.override_debug_info = self.override_debug_info.inverse()
-            return self
         inverse_generated_function = (
             self.generated_function.model_copy(
                 update=dict(registers=self._inverse_registers)
@@ -332,6 +327,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return self.model_copy(
             update=dict(
                 is_inverse=not self.is_inverse,
+                is_daggered=not self.is_daggered,
                 children=inverted_children,
                 generated_function=inverse_generated_function,
             )

classiq/interface/generator/generation_request.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.jobs import JobStatus
+
+
+class SynthesisJobDetails(VersionedModel):
+    id: str
+
+    name: str | None = Field(default=None)
+    start_time: datetime
+    end_time: datetime | None = Field(default=None)
+
+    target_backend: str | None = Field(default=None)
+    backend_name: str | None = Field(default=None)
+    optimization_level: str | None = Field(default=None)
+    optimization_parameter: str | None = Field(default=None)
+
+    status: JobStatus
+
+    program_id: str | None = Field(default=None)
+
+    error: str | None = Field(default=None)
+
+    cost: float | None = Field(default=None)
+
+    random_seed: int | None = Field(default=None)
+    max_width: int | None = Field(default=None)
+    max_gate_count: int | None = Field(default=None)
+
+
+class SynthesisJobsQueryResults(VersionedModel):
+    results: list[SynthesisJobDetails]

classiq/interface/generator/hamiltonian_evolution/exponentiation.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.chemistry import operator
@@ -16,10 +14,10 @@ class ExponentiationOptimization(StrEnum):
 
 
 class ExponentiationConstraints(pydantic.BaseModel):
-    max_depth: Optional[pydantic.PositiveInt] = pydantic.Field(
+    max_depth: pydantic.PositiveInt | None = pydantic.Field(
         default=None, description="Maximum depth of the exponentiation circuit."
     )
-    max_error: Optional[pydantic.PositiveFloat] = pydantic.Field(
+    max_error: pydantic.PositiveFloat | None = pydantic.Field(
         default=None,
         description="Maximum approximation error of the exponentiation circuit.",
     )

classiq/interface/generator/hardware/hardware_data.py

@@ -1,7 +1,7 @@
 import itertools
 from collections import defaultdict
 from collections.abc import MutableSet
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from typing_extensions import Self
@@ -50,7 +50,7 @@ class HardwareData(pydantic.BaseModel):
         f"If no connectivity map is given or the connectivity map is symmetric - {sorted(DEFAULT_BASIS_GATES)}. "
         f"If a non-symmetric connectivity map is given - {sorted(DEFAULT_ROUTING_BASIS_GATES)}. ",
     )
-    connectivity_map: Optional[ConnectivityMap] = pydantic.Field(
+    connectivity_map: ConnectivityMap | None = pydantic.Field(
         default=None,
         description="Qubit connectivity map, in the form [ [q0, q1], [q1, q2],...]. "
         "If none given, assume the hardware is fully connected",
@@ -65,8 +65,8 @@ class HardwareData(pydantic.BaseModel):
     @pydantic.field_validator("connectivity_map")
     @classmethod
     def _validate_connectivity_map(
-        cls, connectivity_map: Optional[ConnectivityMap]
-    ) -> Optional[ConnectivityMap]:
+        cls, connectivity_map: ConnectivityMap | None
+    ) -> ConnectivityMap | None:
         if connectivity_map is None:
             return connectivity_map
         if not connectivity_map:
@@ -128,7 +128,7 @@ class CustomHardwareSettings(HardwareData):
 
     """
 
-    _width: Optional[int] = pydantic.PrivateAttr(default=None)
+    _width: int | None = pydantic.PrivateAttr(default=None)
 
     @pydantic.field_validator("basis_gates", mode="after")
     @classmethod
@@ -144,14 +144,14 @@ class CustomHardwareSettings(HardwareData):
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self._width: Optional[int] = (
+        self._width: int | None = (
             len(set(itertools.chain.from_iterable(self.connectivity_map)))
             if self.connectivity_map
             else None
         )
 
     @property
-    def width(self) -> Optional[int]:
+    def width(self) -> int | None:
         return self._width
 
 
@@ -221,4 +221,4 @@ class SynthesisHardwareData(HardwareData):
             Defaults to `None`.
     """
 
-    backend_data: Optional[BackendPreferences] = pydantic.Field(default=None)
+    backend_data: BackendPreferences | None = pydantic.Field(default=None)