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

classiq/interface/ast_node.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 from uuid import UUID
 
 import pydantic
@@ -13,8 +13,8 @@ ASTNodeType = TypeVar("ASTNodeType", bound="ASTNode")
 
 
 class ASTNode(HashablePydanticBaseModel):
-    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
-    back_ref: Optional[UUID] = pydantic.Field(default=None)
+    source_ref: SourceReference | None = pydantic.Field(default=None)
+    back_ref: UUID | None = pydantic.Field(default=None)
 
     def _as_back_ref(self: Self) -> Self:
         return self

classiq/interface/backend/backend_preferences.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import warnings
 from collections.abc import Iterable
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import pydantic
 from pydantic import BaseModel
@@ -103,19 +103,19 @@ class AliceBobBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.ALICE_BOB = pydantic.Field(
         default=ProviderVendor.ALICE_AND_BOB
     )
-    distance: Optional[int] = pydantic.Field(
+    distance: int | None = pydantic.Field(
         default=None, description="Repetition code distance"
     )
-    kappa_1: Optional[float] = pydantic.Field(
+    kappa_1: float | None = pydantic.Field(
         default=None, description="One-photon dissipation rate (Hz)"
     )
-    kappa_2: Optional[float] = pydantic.Field(
+    kappa_2: float | None = pydantic.Field(
         default=None, description="Two-photon dissipation rate (Hz)"
     )
-    average_nb_photons: Optional[float] = pydantic.Field(
+    average_nb_photons: float | None = pydantic.Field(
         default=None, description="Average number of photons"
     )
-    api_key: Optional[pydantic_backend.PydanticAliceBobApiKeyType] = pydantic.Field(
+    api_key: pydantic_backend.PydanticAliceBobApiKeyType | None = pydantic.Field(
         default=None, description="AliceBob API key"
     )
 
@@ -131,7 +131,7 @@ class AliceBobBackendPreferences(BackendPreferences):
 
     @pydantic.field_validator("api_key", mode="after")
     @classmethod
-    def _validate_api_key(cls, api_key: Optional[str]) -> Optional[str]:
+    def _validate_api_key(cls, api_key: str | None) -> str | None:
         if api_key is not None:
             warnings.warn(
                 "API key is no longer required for Alice&Bob backends.",
@@ -193,14 +193,14 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: Optional[str] = pydantic.Field(
+    aws_role_arn: str | None = pydantic.Field(
         default=None,
         description="ARN of the role to be assumed for execution on your Braket account.",
     )
-    s3_bucket_name: Optional[str] = pydantic.Field(
+    s3_bucket_name: str | None = pydantic.Field(
         default=None, description="S3 Bucket Name"
     )
-    s3_folder: Optional[str] = pydantic.Field(
+    s3_folder: str | None = pydantic.Field(
         default=None, description="S3 Folder Path Within The S3 Bucket"
     )
     run_through_classiq: bool = pydantic.Field(
@@ -229,15 +229,15 @@ class IBMBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.IBM_CLOUD = pydantic.Field(
         default=ProviderVendor.IBM_QUANTUM
     )
-    access_token: Optional[str] = pydantic.Field(
+    access_token: str | None = pydantic.Field(
         default=None,
         description="IBM Cloud access token to be used"
         " with IBM Quantum hosted backends",
     )
-    channel: Optional[str] = pydantic.Field(
+    channel: str | None = pydantic.Field(
         default=None, description="Channel to use for IBM cloud backends."
     )
-    instance_crn: Optional[str] = pydantic.Field(
+    instance_crn: str | None = pydantic.Field(
         default=None, description="IBM Cloud instance CRN."
     )
     run_through_classiq: bool = pydantic.Field(
@@ -303,12 +303,12 @@ class AzureBackendPreferences(BackendPreferences):
         default="East US", description="Azure personal resource region"
     )
 
-    credentials: Optional[AzureCredential] = pydantic.Field(
+    credentials: AzureCredential | None = pydantic.Field(
         default=None,
         description="The service principal credential to access personal quantum workspace",
     )
 
-    ionq_error_mitigation_flag: Optional[bool] = pydantic.Field(
+    ionq_error_mitigation_flag: bool | None = pydantic.Field(
         default=False,
         description="Error mitigation configuration upon running on IonQ through Azure.",
     )
@@ -343,7 +343,7 @@ class IonqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.IONQ = pydantic.Field(
         default=ProviderVendor.IONQ
     )
-    api_key: Optional[pydantic_backend.PydanticIonQApiKeyType] = pydantic.Field(
+    api_key: pydantic_backend.PydanticIonQApiKeyType | None = pydantic.Field(
         default=None, description="IonQ API key"
     )
     error_mitigation: bool = pydantic.Field(

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Annotated, Optional
+from typing import TYPE_CHECKING, Annotated
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -22,10 +22,10 @@ else:
 
 class Gate(BaseModel):
     gate: PydanticGateName
-    target: Optional[int] = None
-    control: Optional[int] = None
-    targets: Optional[list[int]] = None
-    controls: Optional[list[int]] = None
+    target: int | None = None
+    control: int | None = None
+    targets: list[int] | None = None
+    controls: list[int] | None = None
     model_config = ConfigDict(extra="allow")
 
 

classiq/interface/chemistry/ansatz_library.py

@@ -1,13 +1,11 @@
-from typing import Optional
-
 from pydantic import BaseModel
 
 
 class HardwareEfficientConstraints(BaseModel):
     num_qubits: int
-    num_two_qubit_gates: Optional[int] = None
-    num_one_qubit_gates: Optional[int] = None
-    max_depth: Optional[int] = None
+    num_two_qubit_gates: int | None = None
+    num_one_qubit_gates: int | None = None
+    max_depth: int | None = None
 
 
 class HardwareEfficient(BaseModel):

classiq/interface/chemistry/operator.py

@@ -1,7 +1,7 @@
 from collections.abc import Collection, Iterable
 from functools import reduce
 from itertools import combinations
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 import numpy as np
 import pydantic
@@ -65,7 +65,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
 
     @staticmethod
     def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType],
+        coeff: sympy.Expr | ParameterComplexType,
     ) -> ParameterComplexType:
         if isinstance(coeff, str):
             validate_expression_str(coeff)
@@ -219,7 +219,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def from_unzipped_lists(
         cls,
         operators: list[list["Pauli"]],
-        coefficients: Optional[list[complex]] = None,
+        coefficients: list[complex] | None = None,
     ) -> "PauliOperator":
         if coefficients is None:
             coefficients = [1] * len(operators)

classiq/interface/combinatorial_optimization/examples/knapsack.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 import pyomo.core as pyo
 
@@ -7,8 +5,8 @@ import pyomo.core as pyo
 def knapsack(
     values: list[int],
     upper_bound: int,
-    weights: Optional[list[int]] = None,
-    max_weight: Optional[int] = None,
+    weights: list[int] | None = None,
+    max_weight: int | None = None,
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
 

classiq/interface/combinatorial_optimization/examples/tsp_digraph.py

@@ -1,12 +1,11 @@
 import itertools
-from typing import Union
 
 import networkx as nx
 import pyomo.core as pyo
 
 
 def tsp_digraph(
-    graph: nx.DiGraph, source: Union[int, str], sink: Union[int, str], nonedge: int
+    graph: nx.DiGraph, source: int | str, sink: int | str, nonedge: int
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
 

classiq/interface/compression_utils.py

@@ -1,19 +1,18 @@
 import base64
 from collections.abc import Sequence
-from typing import Union
 
 import zstandard as zstd
 from pydantic import BaseModel
 from pydantic_core import from_json, to_json
 
 
-def compress_pydantic(obj: Union[BaseModel, Sequence[BaseModel]]) -> bytes:
+def compress_pydantic(obj: BaseModel | Sequence[BaseModel]) -> bytes:
     json_data = to_json(obj)
     compressed_data = _compress(json_data, level=22)  # max compression level
     return compressed_data
 
 
-def decompress(compressed_data: bytes) -> Union[dict, list[dict]]:
+def decompress(compressed_data: bytes) -> dict | list[dict]:
     decompressed_data = _decompress(compressed_data)
     return from_json(decompressed_data)
 

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping, Sequence
-from typing import Optional, Union, cast
+from typing import Union, cast
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -20,11 +20,11 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
-    statement_type: Union[StatementType, None] = None
+    statement_type: StatementType | None = None
     is_inverse: bool = Field(default=False)
-    control_variable: Optional[str] = Field(default=None)
+    control_variable: str | None = Field(default=None)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
-    node: Optional[ConcreteQuantumStatement] = None
+    node: ConcreteQuantumStatement | None = None
 
     @property
     def is_allocate_or_free(self) -> bool:
@@ -61,7 +61,7 @@ class DebugInfoCollection(BaseModel):
     def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
         self.data[str(key)] = value
 
-    def get(self, key: UUID) -> Optional[FunctionDebugInfo]:
+    def get(self, key: UUID) -> FunctionDebugInfo | None:
         return self.data.get(str(key))
 
     def __getitem__(self, key: UUID) -> FunctionDebugInfo:
@@ -70,7 +70,7 @@ class DebugInfoCollection(BaseModel):
     def __contains__(self, key: UUID) -> bool:
         return str(key) in self.data
 
-    def get_blackbox_data(self, key: UUID) -> Optional[FunctionDebugInfoInterface]:
+    def get_blackbox_data(self, key: UUID) -> FunctionDebugInfoInterface | None:
         if (debug_info := self.get(key)) is None:
             return None
         return self.blackbox_data.get(debug_info.name)
@@ -103,7 +103,7 @@ def new_function_debug_info_by_node(
 
 
 def calculate_port_to_passed_variable_mapping(
-    arg_decls: Sequence[PositionalArg], args: Sequence[Union[ArgValue, None]]
+    arg_decls: Sequence[PositionalArg], args: Sequence[ArgValue | None]
 ) -> dict[str, str]:
     return {
         arg_decl.name: str(cast(ConcreteHandleBinding, arg))

classiq/interface/exceptions.py

@@ -1,6 +1,5 @@
 import logging
 from collections.abc import Iterable
-from typing import Optional
 
 _logger = logging.getLogger(__name__)
 
@@ -53,7 +52,7 @@ class ClassiqAnalyzerVisualizationError(ClassiqError):
 
 
 class ClassiqAPIError(ClassiqError):
-    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+    def __init__(self, message: str, status_code: int | None = None) -> None:
         self.status_code = status_code
         super().__init__(message)
 
@@ -66,6 +65,10 @@ class ClassiqValueError(ClassiqError, ValueError):
     pass
 
 
+class ClassiqTypeError(ClassiqError, TypeError):
+    pass
+
+
 class ClassiqArithmeticError(ClassiqValueError):
     pass
 
@@ -187,7 +190,7 @@ class ClassiqExpansionError(ClassiqError):
 
 
 class ClassiqInternalError(ClassiqError):
-    def __init__(self, message: Optional[str] = None) -> None:
+    def __init__(self, message: str | None = None) -> None:
         final_message = "Internal error occurred. Please contact Classiq support."
         if message is not None:
             final_message += f"\nError: {message}"

classiq/interface/execution/iqcc.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import BaseModel, Field
 
 from classiq.interface.helpers.versioned_model import VersionedModel
@@ -27,7 +25,7 @@ class IQCCAuthItemDetails(BaseModel):
     id: str
     name: str
     description: str
-    scope_id: Optional[str] = Field(default=None)
+    scope_id: str | None = Field(default=None)
 
 
 class IQCCAuthItemsDetails(VersionedModel):

classiq/interface/execution/primitives.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 from pydantic import BaseModel, Field
 
@@ -17,7 +17,7 @@ class MinimizeCostInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     initial_params: Arguments
     max_iteration: int
     quantile: float
-    tolerance: Optional[float]
+    tolerance: float | None
 
 
 class MinimizeClassicalCostInput(MinimizeCostInput):
@@ -41,7 +41,7 @@ ConcreteMinimizeCostInput = Annotated[
 
 
 class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
-    sample: Optional[list[Arguments]] = Field(default=None)
-    estimate: Optional[EstimateInput] = Field(default=None)
-    minimize: Optional[ConcreteMinimizeCostInput] = Field(default=None)
-    random_seed: Optional[int] = Field(default=None)
+    sample: list[Arguments] | None = Field(default=None)
+    estimate: EstimateInput | None = Field(default=None)
+    minimize: ConcreteMinimizeCostInput | None = Field(default=None)
+    random_seed: int | None = Field(default=None)

classiq/interface/executor/estimate_cost.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
 
 import numpy as np
 

classiq/interface/executor/execution_preferences.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.backend.backend_preferences import (
@@ -43,7 +41,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         job_name (Optional[str]): The name of the job, with a minimum length of 1 character.
     """
 
-    noise_properties: Optional[NoiseProperties] = pydantic.Field(
+    noise_properties: NoiseProperties | None = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
     random_seed: int = pydantic.Field(
@@ -53,13 +51,13 @@ class ExecutionPreferences(pydantic.BaseModel):
     backend_preferences: BackendPreferencesTypes = backend_preferences_field(
         backend_name=ClassiqSimulatorBackendNames.SIMULATOR
     )
-    num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+    num_shots: pydantic.PositiveInt | None = pydantic.Field(default=None)
     transpile_to_hardware: TranspilationOption = pydantic.Field(
         default=TranspilationOption.DECOMPOSE,
         description="Transpile the circuit to the hardware basis gates before execution",
         title="Transpilation Option",
     )
-    job_name: Optional[str] = pydantic.Field(
+    job_name: str | None = pydantic.Field(
         min_length=1, description="The job name", default=None
     )
 

classiq/interface/executor/execution_request.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 import pydantic
 from pydantic import BaseModel, Field
@@ -51,28 +51,28 @@ class ProviderJobs(BaseModel):
 class JobCost(BaseModel):
     total_cost: float = Field(default=0)
     currency_code: str = Field(default="USD")
-    organization: Optional[str] = Field(default=None)
+    organization: str | None = Field(default=None)
     jobs: list[ProviderJobs] = Field(default=[])
 
 
 class ExecutionJobDetails(VersionedModel):
     id: str
 
-    name: Optional[str] = Field(default=None)
+    name: str | None = Field(default=None)
     start_time: datetime
-    end_time: Optional[datetime] = Field(default=None)
+    end_time: datetime | None = Field(default=None)
 
-    provider: Optional[str] = Field(default=None)
-    backend_name: Optional[str] = Field(default=None)
+    provider: str | None = Field(default=None)
+    backend_name: str | None = Field(default=None)
 
     status: JobStatus
 
-    num_shots: Optional[int] = Field(default=None)
-    program_id: Optional[str] = Field(default=None)
+    num_shots: int | None = Field(default=None)
+    program_id: str | None = Field(default=None)
 
-    error: Optional[str] = Field(default=None)
+    error: str | None = Field(default=None)
 
-    cost: Optional[JobCost] = Field(default=None)
+    cost: JobCost | None = Field(default=None)
 
 
 class ExecutionJobsQueryResults(VersionedModel):

classiq/interface/executor/execution_result.py

@@ -1,7 +1,6 @@
-from typing import Annotated, Any, Literal, Union
+from typing import Annotated, Any, Literal, TypeAlias, Union
 
 from pydantic import BaseModel, ConfigDict, Field
-from typing_extensions import TypeAlias
 
 from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.enum_utils import StrEnum

classiq/interface/executor/quantum_code.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -35,7 +35,7 @@ class QuantumBaseCode(BaseModel):
     @pydantic.field_validator("code")
     @classmethod
     def load_quantum_program(
-        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
+        cls, code: CodeType | IonqQuantumCircuit, values: ValidationInfo
     ) -> CodeType:
         syntax = values.data.get("syntax")
         if isinstance(code, IonqQuantumCircuit):
@@ -57,11 +57,11 @@ class QuantumCode(QuantumBaseCode):
         default_factory=dict,
         description="The map of outputs to their qubits in the circuit.",
     )
-    registers_initialization: Optional[RegistersInitialization] = pydantic.Field(
+    registers_initialization: RegistersInitialization | None = pydantic.Field(
         default=None,
         description="Initial conditions for the different registers in the circuit.",
     )
-    synthesis_execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
+    synthesis_execution_data: ExecutionData | None = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
     model_config = ConfigDict(validate_assignment=True)
 
@@ -90,9 +90,9 @@ class QuantumCode(QuantumBaseCode):
     @classmethod
     def validate_synthesis_execution_data(
         cls,
-        synthesis_execution_data: Optional[ExecutionData],
+        synthesis_execution_data: ExecutionData | None,
         values: ValidationInfo,
-    ) -> Optional[ExecutionData]:
+    ) -> ExecutionData | None:
         if (
             synthesis_execution_data is not None
             and synthesis_execution_data.function_execution
@@ -103,8 +103,8 @@ class QuantumCode(QuantumBaseCode):
 
     @staticmethod
     def from_file(
-        file_path: Union[str, Path],
-        syntax: Optional[Union[str, QuantumInstructionSet]] = None,
+        file_path: str | Path,
+        syntax: str | QuantumInstructionSet | None = None,
         arguments: MultipleArguments = (),
     ) -> QuantumCode:
         path = Path(file_path)

classiq/interface/executor/result.py

@@ -9,13 +9,13 @@ from typing import (
     Any,
     DefaultDict,
     Optional,
+    TypeAlias,
     Union,
 )
 
-import pandas as pd
 import pydantic
 from pydantic import BaseModel
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from classiq.interface.exceptions import (
     ClassiqError,
@@ -52,6 +52,8 @@ MAGNITUDE = "magnitude"
 PHASE = "phase"
 
 if TYPE_CHECKING:
+    import pandas as pd
+
     DotAccessParsedState = Mapping[Name, Any]
 else:
     DotAccessParsedState = ParsedState
@@ -90,8 +92,8 @@ ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
-    var: Optional[float] = None
-    alpha: Optional[float] = None
+    var: float | None = None
+    alpha: float | None = None
 
 
 class GroverSimulationResults(VersionedModel):
@@ -119,7 +121,7 @@ def flip_counts_qubit_order(counts: Counts) -> Counts:
 
 def get_sampled_state(
     parsed_counts: ParsedCounts, state: ParsedState
-) -> Optional[SampledState]:
+) -> SampledState | None:
     for sampled_state in parsed_counts:
         if sampled_state.state == state:
             return sampled_state
@@ -150,7 +152,7 @@ def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCoun
 
 def prepare_parsed_state_vector(
     state_vector: StateVector, parsed_state_vector_states: ParsedStates
-) -> Optional[ParsedStateVector]:
+) -> ParsedStateVector | None:
     if not state_vector:
         return None
 
@@ -165,7 +167,11 @@ def prepare_parsed_state_vector(
     return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
 
 
-def _flatten_columns(df: pd.DataFrame, columns_to_flatten: list[str]) -> pd.DataFrame:
+def _flatten_columns(
+    df: "pd.DataFrame", columns_to_flatten: list[str]
+) -> "pd.DataFrame":
+    import pandas as pd
+
     if len(df.columns) == 0:
         return df
 
@@ -221,7 +227,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default_factory=dict,
         description="A mapping between the raw states of counts (bitstrings) to their parsed states (registers' values)",
     )
-    histogram: Optional[dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
+    histogram: dict[State, pydantic.NonNegativeFloat] | None = pydantic.Field(
         None,
         description="Histogram of probability per state (an alternative to counts)",
     )
@@ -233,15 +239,15 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None,
         description="The state vector when executed on a simulator, with LSB right qubit order",
     )
-    parsed_state_vector_states: Optional[ParsedStates] = pydantic.Field(
+    parsed_state_vector_states: ParsedStates | None = pydantic.Field(
         default=None,
         description="A mapping between the raw states of the state vector (bitstrings) to their parsed states (registers' values)",
     )
-    physical_qubits_map: Optional[OutputQubitsMap] = pydantic.Field(
+    physical_qubits_map: OutputQubitsMap | None = pydantic.Field(
         default=None,
         description="The map of all registers (also non measured) to their qubits in the circuit. Used for state_vector which represent also the non-measured qubits.",
     )
-    num_shots: Optional[pydantic.NonNegativeInt] = pydantic.Field(
+    num_shots: pydantic.NonNegativeInt | None = pydantic.Field(
         default=None, description="The total number of shots the circuit was executed"
     )
 
@@ -274,7 +280,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return get_parsed_counts(self.counts, self.parsed_states)
 
     @property
-    def parsed_state_vector(self) -> Optional[ParsedStateVector]:
+    def parsed_state_vector(self) -> ParsedStateVector | None:
         if TYPE_CHECKING:
             assert self.parsed_state_vector_states is not None
         return prepare_parsed_state_vector(
@@ -327,7 +333,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return dict(reduced_counts)
 
     def parsed_counts_of_outputs(
-        self, output_names: Union[Name, tuple[Name, ...]]
+        self, output_names: Name | tuple[Name, ...]
     ) -> ParsedCounts:
         if isinstance(output_names, Name):
             output_names = (output_names,)
@@ -361,7 +367,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         )[::-1]
         return number_utils.binary_to_float_or_int(bin_rep=register_binary_string)
 
-    def _counts_df(self) -> pd.DataFrame:
+    def _counts_df(self) -> "pd.DataFrame":
+        import pandas as pd
+
         data: dict[str, Any] = defaultdict(list)
 
         for bitstring, count in self.counts.items():
@@ -382,7 +390,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
         return pd.DataFrame(data, columns=columns)
 
-    def _state_vector_df(self) -> pd.DataFrame:
+    def _state_vector_df(self) -> "pd.DataFrame":
+        import pandas as pd
+
         data: dict[str, Any] = defaultdict(list)
 
         if not self.state_vector:
@@ -408,7 +418,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return pd.DataFrame(data, columns=columns)
 
     @functools.cached_property
-    def dataframe(self) -> pd.DataFrame:
+    def dataframe(self) -> "pd.DataFrame":
         reserved_words = frozenset(
             [BITSTRING, PROBABILITY, COUNT, AMPLITUDE, PHASE, MAGNITUDE]
         )
@@ -449,9 +459,9 @@ class MultipleExecutionDetails(VersionedModel):
 
 
 class EstimationMetadata(BaseModel, extra="allow"):
-    shots: Optional[pydantic.NonNegativeInt] = None
+    shots: pydantic.NonNegativeInt | None = None
     remapped_qubits: bool = False
-    input_qubit_map: Optional[list[PydanticNonNegIntTuple]] = None
+    input_qubit_map: list[PydanticNonNegIntTuple] | None = None
 
 
 class EstimationResult(BaseModel, QmodPyObject):