qhub-api 3.2.2rc2__tar.gz → 3.3.0__tar.gz

{qhub_api-3.2.2rc2 → qhub_api-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: qhub-api
-Version: 3.2.2rc2
+Version: 3.3.0
 Summary: SDK to interact with the official Kipu Quantum Hub APIs.
 Project-URL: Homepage, https://hub.kipu-quantum.com
 Project-URL: Documentation, https://docs.hub.kipu-quantum.com
@@ -211,7 +211,7 @@ License:
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pydantic>=2.8.0
 Description-Content-Type: text/markdown
 
 # Kipu Quantum Hub API SDK

{qhub_api-3.2.2rc2 → qhub_api-3.3.0}/pyproject.toml

@@ -15,7 +15,7 @@ license = { file = "LICENSE" }
 requires-python = ">=3.10"
 dependencies = [
     "httpx>=0.28.1",
-    "pydantic>=2.5.0",
+    "pydantic>=2.8.0",
 ]
 
 [dependency-groups]

{qhub_api-3.2.2rc2 → qhub_api-3.3.0}/qhub/api/quantum/__init__.py

@@ -51,7 +51,11 @@ if typing.TYPE_CHECKING:
         BackendStateInfoStatus,
         BackendTechnology,
         BackendType,
+        CalibrationMedians,
         CalibrationResponse,
+        CalibrationResponseCalibration,
+        CalibrationResponseCalibration_GateBased,
+        CalibrationResponseCalibration_QueraAquila,
         Configuration,
         ConfigurationOutputFormat,
         ConfigurationSupportedInputFormatsItem,
@@ -59,6 +63,8 @@ if typing.TYPE_CHECKING:
         Documentation,
         EstimatorRunContext,
         Gate,
+        GateBasedCalibration,
+        GateCalibration,
         IbmJobInput,
         IbmJobInputCircuits,
         IbmJobInputCircuitsOptions,
@@ -154,10 +160,13 @@ if typing.TYPE_CHECKING:
         QuandelaJobInput,
         QuandelaJobInputParams,
         Qubit,
+        QubitCalibration,
+        QubitPairCalibration,
         QudoraJobInput,
         QudoraJobInputParams,
         QudoraJobInputParamsLanguage,
         QudoraJobInputQasm,
+        QueraAquilaCalibration,
         RuntimeMinutesAllowance,
         RuntimeMinutesAllowanceProvider,
         RuntimeMinutesResponse,
@@ -411,7 +420,11 @@ _dynamic_imports: typing.Dict[str, str] = {
     "BackendType": ".types",
     "BadGatewayError": ".errors",
     "BadRequestError": ".errors",
+    "CalibrationMedians": ".types",
     "CalibrationResponse": ".types",
+    "CalibrationResponseCalibration": ".types",
+    "CalibrationResponseCalibration_GateBased": ".types",
+    "CalibrationResponseCalibration_QueraAquila": ".types",
     "Configuration": ".types",
     "ConfigurationOutputFormat": ".types",
     "ConfigurationSupportedInputFormatsItem": ".types",
@@ -594,6 +607,8 @@ _dynamic_imports: typing.Dict[str, str] = {
     "EstimatorRunContext": ".types",
     "ForbiddenError": ".errors",
     "Gate": ".types",
+    "GateBasedCalibration": ".types",
+    "GateCalibration": ".types",
     "HubQuantumClient": ".client",
     "HubQuantumClientEnvironment": ".environment",
     "IbmJobInput": ".types",
@@ -693,10 +708,13 @@ _dynamic_imports: typing.Dict[str, str] = {
     "QuandelaJobInput": ".types",
     "QuandelaJobInputParams": ".types",
     "Qubit": ".types",
+    "QubitCalibration": ".types",
+    "QubitPairCalibration": ".types",
     "QudoraJobInput": ".types",
     "QudoraJobInputParams": ".types",
     "QudoraJobInputParamsLanguage": ".types",
     "QudoraJobInputQasm": ".types",
+    "QueraAquilaCalibration": ".types",
     "RuntimeMinutesAllowance": ".types",
     "RuntimeMinutesAllowanceProvider": ".types",
     "RuntimeMinutesResponse": ".types",
@@ -795,7 +813,11 @@ __all__ = [
     "BackendType",
     "BadGatewayError",
     "BadRequestError",
+    "CalibrationMedians",
     "CalibrationResponse",
+    "CalibrationResponseCalibration",
+    "CalibrationResponseCalibration_GateBased",
+    "CalibrationResponseCalibration_QueraAquila",
     "Configuration",
     "ConfigurationOutputFormat",
     "ConfigurationSupportedInputFormatsItem",
@@ -978,6 +1000,8 @@ __all__ = [
     "EstimatorRunContext",
     "ForbiddenError",
     "Gate",
+    "GateBasedCalibration",
+    "GateCalibration",
     "HubQuantumClient",
     "HubQuantumClientEnvironment",
     "IbmJobInput",
@@ -1077,10 +1101,13 @@ __all__ = [
     "QuandelaJobInput",
     "QuandelaJobInputParams",
     "Qubit",
+    "QubitCalibration",
+    "QubitPairCalibration",
     "QudoraJobInput",
     "QudoraJobInputParams",
     "QudoraJobInputParamsLanguage",
     "QudoraJobInputQasm",
+    "QueraAquilaCalibration",
     "RuntimeMinutesAllowance",
     "RuntimeMinutesAllowanceProvider",
     "RuntimeMinutesResponse",

{qhub_api-3.2.2rc2 → qhub_api-3.3.0}/qhub/api/quantum/types/__init__.py

@@ -78,7 +78,13 @@ if typing.TYPE_CHECKING:
     from .backend_state_info_status import BackendStateInfoStatus
     from .backend_technology import BackendTechnology
     from .backend_type import BackendType
+    from .calibration_medians import CalibrationMedians
     from .calibration_response import CalibrationResponse
+    from .calibration_response_calibration import (
+        CalibrationResponseCalibration,
+        CalibrationResponseCalibration_GateBased,
+        CalibrationResponseCalibration_QueraAquila,
+    )
     from .configuration import Configuration
     from .configuration_output_format import ConfigurationOutputFormat
     from .configuration_supported_input_formats_item import ConfigurationSupportedInputFormatsItem
@@ -86,6 +92,8 @@ if typing.TYPE_CHECKING:
     from .documentation import Documentation
     from .estimator_run_context import EstimatorRunContext
     from .gate import Gate
+    from .gate_based_calibration import GateBasedCalibration
+    from .gate_calibration import GateCalibration
     from .ibm_job_input import IbmJobInput
     from .ibm_job_input_circuits import IbmJobInputCircuits
     from .ibm_job_input_circuits_options import IbmJobInputCircuitsOptions
@@ -219,10 +227,13 @@ if typing.TYPE_CHECKING:
     from .quandela_job_input import QuandelaJobInput
     from .quandela_job_input_params import QuandelaJobInputParams
     from .qubit import Qubit
+    from .qubit_calibration import QubitCalibration
+    from .qubit_pair_calibration import QubitPairCalibration
     from .qudora_job_input import QudoraJobInput
     from .qudora_job_input_params import QudoraJobInputParams
     from .qudora_job_input_params_language import QudoraJobInputParamsLanguage
     from .qudora_job_input_qasm import QudoraJobInputQasm
+    from .quera_aquila_calibration import QueraAquilaCalibration
     from .runtime_minutes_allowance import RuntimeMinutesAllowance
     from .runtime_minutes_allowance_provider import RuntimeMinutesAllowanceProvider
     from .runtime_minutes_response import RuntimeMinutesResponse
@@ -287,7 +298,11 @@ _dynamic_imports: typing.Dict[str, str] = {
     "BackendStateInfoStatus": ".backend_state_info_status",
     "BackendTechnology": ".backend_technology",
     "BackendType": ".backend_type",
+    "CalibrationMedians": ".calibration_medians",
     "CalibrationResponse": ".calibration_response",
+    "CalibrationResponseCalibration": ".calibration_response_calibration",
+    "CalibrationResponseCalibration_GateBased": ".calibration_response_calibration",
+    "CalibrationResponseCalibration_QueraAquila": ".calibration_response_calibration",
     "Configuration": ".configuration",
     "ConfigurationOutputFormat": ".configuration_output_format",
     "ConfigurationSupportedInputFormatsItem": ".configuration_supported_input_formats_item",
@@ -295,6 +310,8 @@ _dynamic_imports: typing.Dict[str, str] = {
     "Documentation": ".documentation",
     "EstimatorRunContext": ".estimator_run_context",
     "Gate": ".gate",
+    "GateBasedCalibration": ".gate_based_calibration",
+    "GateCalibration": ".gate_calibration",
     "IbmJobInput": ".ibm_job_input",
     "IbmJobInputCircuits": ".ibm_job_input_circuits",
     "IbmJobInputCircuitsOptions": ".ibm_job_input_circuits_options",
@@ -390,10 +407,13 @@ _dynamic_imports: typing.Dict[str, str] = {
     "QuandelaJobInput": ".quandela_job_input",
     "QuandelaJobInputParams": ".quandela_job_input_params",
     "Qubit": ".qubit",
+    "QubitCalibration": ".qubit_calibration",
+    "QubitPairCalibration": ".qubit_pair_calibration",
     "QudoraJobInput": ".qudora_job_input",
     "QudoraJobInputParams": ".qudora_job_input_params",
     "QudoraJobInputParamsLanguage": ".qudora_job_input_params_language",
     "QudoraJobInputQasm": ".qudora_job_input_qasm",
+    "QueraAquilaCalibration": ".quera_aquila_calibration",
     "RuntimeMinutesAllowance": ".runtime_minutes_allowance",
     "RuntimeMinutesAllowanceProvider": ".runtime_minutes_allowance_provider",
     "RuntimeMinutesResponse": ".runtime_minutes_response",
@@ -482,7 +502,11 @@ __all__ = [
     "BackendStateInfoStatus",
     "BackendTechnology",
     "BackendType",
+    "CalibrationMedians",
     "CalibrationResponse",
+    "CalibrationResponseCalibration",
+    "CalibrationResponseCalibration_GateBased",
+    "CalibrationResponseCalibration_QueraAquila",
     "Configuration",
     "ConfigurationOutputFormat",
     "ConfigurationSupportedInputFormatsItem",
@@ -490,6 +514,8 @@ __all__ = [
     "Documentation",
     "EstimatorRunContext",
     "Gate",
+    "GateBasedCalibration",
+    "GateCalibration",
     "IbmJobInput",
     "IbmJobInputCircuits",
     "IbmJobInputCircuitsOptions",
@@ -585,10 +611,13 @@ __all__ = [
     "QuandelaJobInput",
     "QuandelaJobInputParams",
     "Qubit",
+    "QubitCalibration",
+    "QubitPairCalibration",
     "QudoraJobInput",
     "QudoraJobInputParams",
     "QudoraJobInputParamsLanguage",
     "QudoraJobInputQasm",
+    "QueraAquilaCalibration",
     "RuntimeMinutesAllowance",
     "RuntimeMinutesAllowanceProvider",
     "RuntimeMinutesResponse",

qhub_api-3.3.0/qhub/api/quantum/types/calibration_medians.py

@@ -0,0 +1,82 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .gate_calibration import GateCalibration
+
+
+class CalibrationMedians(UniversalBaseModel):
+    """
+    Backend-wide medians, each taken over the operational qubits (or pairs of operational qubits) that report the value. Same units and meaning as the per-qubit fields.
+    """
+
+    t1_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median T1 in microseconds.
+    """
+
+    t1_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median T1 standard deviation in microseconds.
+    """
+
+    t2_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median T2 in microseconds.
+    """
+
+    t2_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median T2 standard deviation in microseconds.
+    """
+
+    t2_echo_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median echo T2 in microseconds.
+    """
+
+    t2_echo_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median echo T2 standard deviation in microseconds.
+    """
+
+    readout_error: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median readout error, a fraction in [0, 1].
+    """
+
+    readout_error_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median readout error standard deviation.
+    """
+
+    readout_length_ns: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median measurement duration in nanoseconds.
+    """
+
+    reset_length_ns: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Median reset duration in nanoseconds.
+    """
+
+    spam_error: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    State preparation and measurement error, a fraction in [0, 1]; only providers that report it.
+    """
+
+    gates: typing.Dict[str, GateCalibration] = pydantic.Field()
+    """
+    Median per gate name over every operational gate of an operational qubit or pair; a median entry is always operational.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

{qhub_api-3.2.2rc2 → qhub_api-3.3.0}/qhub/api/quantum/types/calibration_response.py

@@ -5,6 +5,7 @@ import typing
 
 import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .calibration_response_calibration import CalibrationResponseCalibration
 
 
 class CalibrationResponse(UniversalBaseModel):
@@ -12,17 +13,20 @@ class CalibrationResponse(UniversalBaseModel):
     Calibration snapshot for a quantum backend at a specific point in time. The shape of the calibration payload depends on the backend technology (e.g. gate-based vs. neutral-atom).
     """
 
-    backend_id: typing.Optional[str] = pydantic.Field(default=None)
+    backend_id: str = pydantic.Field()
     """
     Unique backend identifier
     """
 
-    calibrated_at: typing.Optional[dt.datetime] = pydantic.Field(default=None)
+    calibrated_at: dt.datetime = pydantic.Field()
     """
     Instant at which the calibration was effective on the backend.
     """
 
-    calibration: typing.Optional[typing.Dict[str, typing.Any]] = None
+    calibration: CalibrationResponseCalibration = pydantic.Field()
+    """
+    The calibration itself: gate-based for every QPU but QuEra Aquila, whose analog calibration keeps its own shape.
+    """
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

qhub_api-3.3.0/qhub/api/quantum/types/calibration_response_calibration.py

@@ -0,0 +1,59 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+
+import typing
+
+import pydantic
+import typing_extensions
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .calibration_medians import CalibrationMedians
+from .qubit_calibration import QubitCalibration
+from .qubit_pair_calibration import QubitPairCalibration
+
+
+class CalibrationResponseCalibration_GateBased(UniversalBaseModel):
+    """
+    The calibration itself: gate-based for every QPU but QuEra Aquila, whose analog calibration keeps its own shape.
+    """
+
+    type: typing.Literal["gate_based"] = "gate_based"
+    medians: CalibrationMedians
+    qubits: typing.List[QubitCalibration]
+    qubit_pairs: typing.List[QubitPairCalibration]
+    native_gate_calibration: typing.Optional[str] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow
+
+
+class CalibrationResponseCalibration_QueraAquila(UniversalBaseModel):
+    """
+    The calibration itself: gate-based for every QPU but QuEra Aquila, whose analog calibration keeps its own shape.
+    """
+
+    type: typing.Literal["quera_aquila"] = "quera_aquila"
+    lattice: typing.Optional[typing.Dict[str, typing.Any]] = None
+    rydberg: typing.Optional[typing.Dict[str, typing.Any]] = None
+    performance: typing.Optional[typing.Dict[str, typing.Any]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow
+
+
+CalibrationResponseCalibration = typing_extensions.Annotated[
+    typing.Union[CalibrationResponseCalibration_GateBased, CalibrationResponseCalibration_QueraAquila],
+    pydantic.Field(discriminator="type"),
+]

qhub_api-3.3.0/qhub/api/quantum/types/gate_based_calibration.py

@@ -0,0 +1,40 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .calibration_medians import CalibrationMedians
+from .qubit_calibration import QubitCalibration
+from .qubit_pair_calibration import QubitPairCalibration
+
+
+class GateBasedCalibration(UniversalBaseModel):
+    """
+    Calibration of a gate-based backend in the provider's natural units: coherence times in microseconds, durations in nanoseconds, qualities as errors in [0, 1], at the provider's full precision.
+    """
+
+    medians: CalibrationMedians
+    qubits: typing.List[QubitCalibration] = pydantic.Field()
+    """
+    One entry per qubit the provider reports, by ascending index. Empty where the provider reports only backend-wide figures.
+    """
+
+    qubit_pairs: typing.List[QubitPairCalibration] = pydantic.Field()
+    """
+    One entry per coupled pair the provider reports. Empty where the provider reports only backend-wide figures.
+    """
+
+    native_gate_calibration: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Where to fetch Rigetti's pulse-level native gate calibration; absent on every other provider.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

qhub_api-3.3.0/qhub/api/quantum/types/gate_calibration.py

@@ -0,0 +1,41 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class GateCalibration(UniversalBaseModel):
+    """
+    Quality and duration of one gate as the provider measured it. Every measured field is absent where the provider reports nothing for it.
+    """
+
+    operational: bool = pydantic.Field()
+    """
+    False when the provider marks the gate as dead. A dead gate is left out of its gate median.
+    """
+
+    error: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Error of the gate, a fraction in [0, 1]; 0 is a perfect gate.
+    """
+
+    error_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Standard deviation of the error.
+    """
+
+    length_ns: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Duration of the gate in nanoseconds.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

qhub_api-3.3.0/qhub/api/quantum/types/qubit_calibration.py

@@ -0,0 +1,102 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .gate_calibration import GateCalibration
+
+
+class QubitCalibration(UniversalBaseModel):
+    """
+    Calibration of one qubit: coherence times in microseconds, readout and reset in nanoseconds and errors, and its single-qubit gates keyed by gate name. A field is absent where the provider reports nothing for it.
+    """
+
+    qubit: int = pydantic.Field()
+    """
+    Index of the qubit, the one a circuit addresses.
+    """
+
+    name: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Name the provider gives the qubit, where it names them.
+    """
+
+    operational: bool = pydantic.Field()
+    """
+    False when the provider marks the qubit as dead. A dead qubit is left out of every median.
+    """
+
+    t1_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    T1 energy-relaxation time in microseconds.
+    """
+
+    t1_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Standard deviation of T1 in microseconds.
+    """
+
+    t2_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    T2 dephasing time in microseconds.
+    """
+
+    t2_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Standard deviation of T2 in microseconds.
+    """
+
+    t2_echo_us: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    T2 measured with a spin-echo sequence, in microseconds.
+    """
+
+    t2_echo_us_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Standard deviation of the echo T2 in microseconds.
+    """
+
+    readout_error: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Probability that a measurement returns the wrong bit, a fraction in [0, 1].
+    """
+
+    readout_error_std: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Standard deviation of the readout error.
+    """
+
+    readout_length_ns: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Duration of a measurement in nanoseconds.
+    """
+
+    reset_length_ns: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Duration of a reset in nanoseconds.
+    """
+
+    prob_meas0_prep1: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Probability of measuring 0 after preparing 1, a fraction in [0, 1].
+    """
+
+    prob_meas1_prep0: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Probability of measuring 1 after preparing 0, a fraction in [0, 1].
+    """
+
+    gates: typing.Dict[str, GateCalibration] = pydantic.Field()
+    """
+    Single-qubit gates keyed by the provider's gate name, or by `one_qubit` where the provider reports one figure for every single-qubit gate. Measurement and reset are not gates here; they have their own fields.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

qhub_api-3.3.0/qhub/api/quantum/types/qubit_pair_calibration.py

@@ -0,0 +1,32 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .gate_calibration import GateCalibration
+
+
+class QubitPairCalibration(UniversalBaseModel):
+    """
+    Calibration of the two-qubit gates on one coupled pair. A pair appears once; a directional gate keeps its direction in the gate name.
+    """
+
+    qubits: typing.List[int] = pydantic.Field()
+    """
+    The two qubit indices, ascending.
+    """
+
+    gates: typing.Dict[str, GateCalibration] = pydantic.Field()
+    """
+    Two-qubit gates keyed by the provider's gate name, or by `two_qubit` where the provider reports one figure for every two-qubit gate.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

qhub_api-3.3.0/qhub/api/quantum/types/quera_aquila_calibration.py

@@ -0,0 +1,25 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class QueraAquilaCalibration(UniversalBaseModel):
+    """
+    Calibration payload for QuEra Aquila neutral-atom backends: lattice geometry, Rydberg Hamiltonian parameters, and performance characteristics. Values are returned as provider-native JSON.
+    """
+
+    lattice: typing.Optional[typing.Dict[str, typing.Any]] = None
+    rydberg: typing.Optional[typing.Dict[str, typing.Any]] = None
+    performance: typing.Optional[typing.Dict[str, typing.Any]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow