boulder-opal-scale-up-sdk 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

{boulder_opal_scale_up_sdk-1.0.3.dist-info → boulder_opal_scale_up_sdk-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: boulder-opal-scale-up-sdk
-Version: 1.0.3
+Version: 1.0.5
 Summary: Q-CTRL Boulder Opal Scale Up Python SDK
 License: https://q-ctrl.com/terms
 Keywords: black opal,boulder opal,fire opal,nisq,open controls,q control,q ctrl,q-control,q-ctrl,qcontrol,qctrl,quantum,quantum algorithms,quantum circuits,quantum coding,quantum coding software,quantum computing,quantum control,quantum control software,quantum control theory,quantum engineering,quantum error correction,quantum firmware,quantum fundamentals,quantum sensing,qubit,qudit

boulder_opal_scale_up_sdk-1.0.5.dist-info/RECORD

@@ -0,0 +1,73 @@
+boulderopalscaleupsdk/__init__.py,sha256=nD3YDqPiE52mmuUrIlDUrYSyljpMsDJvc5HsubBUSs4,592
+boulderopalscaleupsdk/agent/__init__.py,sha256=aFkAtHJDOdXA126JklxYz0ix1k4lCcLLS9DQp8zUKMk,1092
+boulderopalscaleupsdk/agent/worker.py,sha256=uQ7VxTGtx_CHeHE0n7V1_KmFpk0OwKoIZxiAtjeRiug,8703
+boulderopalscaleupsdk/common/__init__.py,sha256=vLaJ1FP36xV5eX6VD7nShqxVBm3UzsBMIK1pmSiTIag,550
+boulderopalscaleupsdk/common/dtypes.py,sha256=8YDF2SzJerA0HQ6UwyY6CU3e6_eeSC2VboA-YI7aD-A,10180
+boulderopalscaleupsdk/common/typeclasses.py,sha256=dUpM4vDNQCxVuB45LTyEWO7SuLyzUlG6mJuseM80Chw,3668
+boulderopalscaleupsdk/device/__init__.py,sha256=vLaJ1FP36xV5eX6VD7nShqxVBm3UzsBMIK1pmSiTIag,550
+boulderopalscaleupsdk/device/common.py,sha256=NxiFdpHXd1Es2_8iqUeAqhL4R4W-POzHoWYtu13JCyo,1875
+boulderopalscaleupsdk/device/config_loader.py,sha256=kGUaUtYAREYN7grtQ9SUO3dPUqiHVUnVOQbXFZpXvtw,3414
+boulderopalscaleupsdk/device/controller/__init__.py,sha256=ePkrCbX1ORm05fS0BEQ8cx7DPxGGN6IkUoNH6eQL1DM,1136
+boulderopalscaleupsdk/device/controller/base.py,sha256=xuT4VzRulknxppiQpzYYn_TwuRNfV9wHMqjN2okA8Lw,793
+boulderopalscaleupsdk/device/controller/qblox.py,sha256=c5RXqS9z2e-6Kso_eJIznIqJMR0kqL1NJRvJboYLafE,29377
+boulderopalscaleupsdk/device/controller/quantum_machines.py,sha256=m0_zO7Cn-Ea1-ewG7qgjEnt4GXtQMvBv_oz-dnOmI9k,5320
+boulderopalscaleupsdk/device/controller/resolver.py,sha256=hW5U58dmJf_IGmD4EK_bbn0XU-N9autFBFHmqbRnY2Y,3812
+boulderopalscaleupsdk/device/defcal.py,sha256=3IPmcLx89ZDv9sCPncozWA-hhnZRZK3OiOiBcAW05lI,739
+boulderopalscaleupsdk/device/device.py,sha256=smNgGtPs4xx2xyBiEtu178EiAW0ylMklv-wOSSnvoGA,2212
+boulderopalscaleupsdk/device/processor/__init__.py,sha256=YLn1UTCIX0CYfah1muLXrhujJx7sz56JZQ4Pn4DnKd0,972
+boulderopalscaleupsdk/device/processor/common.py,sha256=1ot1MbK6P1rZspX9bpfFXUSzlzr70x0GIDAVsFKcMTA,9667
+boulderopalscaleupsdk/device/processor/superconducting_processor.py,sha256=pt4hWdRoBD8EWYlG1HDPfumZNdRzo7Be9FDqHoRAFDw,13394
+boulderopalscaleupsdk/experiments/__init__.py,sha256=nXAkD_BQYYDbd4_ZGLWoO2NsYllJRKV1oVr0i2V1yQ0,2304
+boulderopalscaleupsdk/experiments/chi01_scan.py,sha256=vcvRbC7UyE_7UfduhcaVJEo5qJxwXQcPTjigXOKBtCc,2280
+boulderopalscaleupsdk/experiments/common.py,sha256=m-A91hOcLYHBqL9jUI4-ia_13U0-wv711aMgCyjiGqw,2535
+boulderopalscaleupsdk/experiments/drag_leakage_calibration.py,sha256=ey0g5hJBGgrtGdwtrMXGCYvd6TvgWIG63wfSJ6ahGzE,2400
+boulderopalscaleupsdk/experiments/fine_amplitude_calibration.py,sha256=3Us-C9Ss5Ks-1TYSIYToEY1hgZr2VF2CY22cgOWk530,1963
+boulderopalscaleupsdk/experiments/power_rabi.py,sha256=-0iT1KHY-HecEvjJ5nQcmWyRNd1505xfVmG_j1gqZXs,2453
+boulderopalscaleupsdk/experiments/power_rabi_ef.py,sha256=j-XoGcNXPtb-NiwwuXhqZaGl70Fh5RKsdZNFSO2hHz0,2461
+boulderopalscaleupsdk/experiments/ramsey.py,sha256=Ym1dqAs3b3nPfNp4T3TPIMTDDMT6eBJ-CUCua9CyKl8,2192
+boulderopalscaleupsdk/experiments/readout_classifier_calibration.py,sha256=k7P1PDbpSz_KjRt4A39ilhA_Ke9IpMKAjoFqT_9RfWY,1841
+boulderopalscaleupsdk/experiments/resonator_spectroscopy.py,sha256=QMEh52zh-ZsraYn2sq7qnE0g0z0dhBsSndIepBrBzVM,2262
+boulderopalscaleupsdk/experiments/resonator_spectroscopy_by_bias.py,sha256=CCZ6AkQ_Q5zfuDpcFe-AI-SLHUUtFnxiPUwS4Y5Xo2Q,2888
+boulderopalscaleupsdk/experiments/resonator_spectroscopy_by_power.py,sha256=jtQHeeQyshlg9_WJwwFONk6FKWRbE88zURwyihY4ZxI,2383
+boulderopalscaleupsdk/experiments/t1.py,sha256=Tia4siBGcQ2-WkKw8F5y6smwW5_h3INbKUxM1nPiufI,1635
+boulderopalscaleupsdk/experiments/t2.py,sha256=LQHwFyOLa0MiVUxRCcovGBVC32bfA7xzfBILgXq0CCs,1790
+boulderopalscaleupsdk/experiments/t2_echo.py,sha256=dgohfuliI2f3KsiyhfSMrwJjwq5r3meakEPmH-3HUAY,1804
+boulderopalscaleupsdk/experiments/transmon_anharmonicity.py,sha256=QELWV3X_sD2ZN1_JwUcS8E4ykYGSW4a7zFPpKuXbjdk,2841
+boulderopalscaleupsdk/experiments/transmon_spectroscopy.py,sha256=y6aZwW2jys5JOYqozfTKpLU5ZXlwP1AQVm73MWO-zB4,2402
+boulderopalscaleupsdk/experiments/voltage_bias_fine_tune.py,sha256=P5RuASiP3UUudLQIFWIznTuhCOK0ndj9FN9l6bHv_xU,2060
+boulderopalscaleupsdk/experiments/waveforms.py,sha256=zyzADCra9T0wphltrhfj75wB2y4qwTSvcU2mBJQNrjU,1712
+boulderopalscaleupsdk/experiments/zz_ramsey.py,sha256=mpek0jKVdbOUnXb0KNYsxGTo3MnMR8SG4cYiHOA1KY4,2017
+boulderopalscaleupsdk/grpc_interceptors/__init__.py,sha256=PkdOlllLbRWycofvGCCxDY60Ydp_U0QM5l4u3Fsnno4,616
+boulderopalscaleupsdk/grpc_interceptors/auth.py,sha256=PSe_b9ckqhcb3xf1Y4jpn1TjfEWfokkarqfUHIz6HIs,4165
+boulderopalscaleupsdk/plotting/__init__.py,sha256=pkdCky3YHqc3PLRy_h9puJKAO4AqSJGebb26x7XayR4,959
+boulderopalscaleupsdk/plotting/dtypes.py,sha256=Ir-aFywqHeq0cI2jHY1uexjJHYpXOZwsg5nts9tpeQc,4892
+boulderopalscaleupsdk/protobuf/v1/agent_pb2.py,sha256=r8vE_d7e5iG04UCDeV0FgxOVOSflOlwmSs2I5CotDBU,6147
+boulderopalscaleupsdk/protobuf/v1/agent_pb2.pyi,sha256=bwRNbnwbwkqx7OSE4EurVS6865zqdtqmTcRjwJNH7OI,3082
+boulderopalscaleupsdk/protobuf/v1/agent_pb2_grpc.py,sha256=gfv0Ncc6_MS38Lzj6NHYXhwJVo7qK7XYQiCsi-KTl5w,8593
+boulderopalscaleupsdk/protobuf/v1/device_pb2.py,sha256=yvgsfFYM-O3LsMlcoVah3CngYxg1djHkkaztD__PE7Q,11599
+boulderopalscaleupsdk/protobuf/v1/device_pb2.pyi,sha256=GqrIb_5V6x4yQHzbJHilS_GGnlDsyhFr_RCratS2KFc,6846
+boulderopalscaleupsdk/protobuf/v1/device_pb2_grpc.py,sha256=0CtrO8gKkcfHn7flQLFAySyOVpdDgzct_EaMMF73rUY,19445
+boulderopalscaleupsdk/protobuf/v1/task_pb2.py,sha256=Sd-xzEOJkEZAFw_A0cNXVKOZ_Q71XrIkMl8OTuL9zoo,7132
+boulderopalscaleupsdk/protobuf/v1/task_pb2.pyi,sha256=o4QeMmUCT_x19eL7dlNE0LtdqJi1e9kv2gMiD7Z4pwg,6048
+boulderopalscaleupsdk/protobuf/v1/task_pb2_grpc.py,sha256=yP2FZ148RmSYFHivatCXuM13oRBDA5wBwmvhZQNBTXQ,5826
+boulderopalscaleupsdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boulderopalscaleupsdk/routines/__init__.py,sha256=4oxML7Ztq7gRWtvDZW_-QUr_Svez8kKIxXIuYhT3LyU,1009
+boulderopalscaleupsdk/routines/common.py,sha256=BvZ1DvCJDFHkauOEq8z-Mkj_mwO-1BSRLHkiTaIbJ0U,775
+boulderopalscaleupsdk/routines/one_qubit_calibration.py,sha256=n3QifgKVcQu0Idkxj0Hk9husi3xcsoMJz7t3nTvBwEk,1018
+boulderopalscaleupsdk/routines/resonator_mapping.py,sha256=Jp7ubmP0knRaoSE6IZnww2q0tixmjZ1HG3NjvEW0Rhs,1186
+boulderopalscaleupsdk/routines/transmon_coherence.py,sha256=qwFlrDgwRdo4rWwXJoQ0pLJSKiUnzMYasK6kMHWhlHI,1074
+boulderopalscaleupsdk/routines/transmon_discovery.py,sha256=ZI-mQQSlUWhU1J_H1ie9Hz4TOK3aMxZqtfX2AgHNrKI,1453
+boulderopalscaleupsdk/routines/transmon_retuning.py,sha256=3C9iSE7D3dnPbj-RJw5pogAwS3Hs9C-9uBLQT81qeAA,1423
+boulderopalscaleupsdk/stubs/__init__.py,sha256=vLaJ1FP36xV5eX6VD7nShqxVBm3UzsBMIK1pmSiTIag,550
+boulderopalscaleupsdk/stubs/dtypes.py,sha256=VH2QqmmaSegv03KEaZBqB-REHhvk5h3GPfQgCJTAYQE,1361
+boulderopalscaleupsdk/stubs/maps.py,sha256=oSGfEOCGSAZjqDRVbHr0B7S3VnyV1pvdRBa5NqnXxuA,1087
+boulderopalscaleupsdk/third_party/__init__.py,sha256=b9T2IVfz9bMenSsLQuaf4A14ySinjNnSGx68hLsFHZE,596
+boulderopalscaleupsdk/third_party/quantum_machines/__init__.py,sha256=ORD6crMw6gtoIp8dmusdwSiU4pje739fOacOfHXSOls,2541
+boulderopalscaleupsdk/third_party/quantum_machines/config.py,sha256=tQsWx_nSXSFT4fRuMzuvliplyRsB9Sy70kHqsKuTA-A,20756
+boulderopalscaleupsdk/third_party/quantum_machines/constants.py,sha256=5PpAi6MZ53yEinBHerY2ssi30BR37JnLBWL21irpZ8Y,870
+boulderopalscaleupsdk/utils/__init__.py,sha256=vLaJ1FP36xV5eX6VD7nShqxVBm3UzsBMIK1pmSiTIag,550
+boulderopalscaleupsdk/utils/serial_utils.py,sha256=SzvY-WFD0b8IGSh6PTv7F9y1W2IPPYmj8pY3AsX-xlM,2062
+boulder_opal_scale_up_sdk-1.0.5.dist-info/LICENSE,sha256=wqX4S5Brcwkwo750l9grSspwm0cyMsZtZEa1Vx3_WiE,36587
+boulder_opal_scale_up_sdk-1.0.5.dist-info/METADATA,sha256=6XkaUQrGLbPksehJqwigcC3NAMujG9JNeS4vWrsbCi8,2419
+boulder_opal_scale_up_sdk-1.0.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+boulder_opal_scale_up_sdk-1.0.5.dist-info/RECORD,,

boulderopalscaleupsdk/agent/worker.py

@@ -54,11 +54,13 @@ class TaskHandler(Protocol):
         self,
         request: agent_pb2.RunProgramRequest
         | agent_pb2.RunQuantumMachinesMixerCalibrationRequest
-        | agent_pb2.DisplayResultsRequest,
+        | agent_pb2.DisplayResultsRequest
+        | agent_pb2.AskRequest,
     ) -> (
         agent_pb2.RunProgramResponse
         | agent_pb2.RunQuantumMachinesMixerCalibrationResponse
         | agent_pb2.DisplayResultsResponse
+        | agent_pb2.AskResponse
         | task_pb2.TaskErrorDetail
     ): ...
 
@@ -67,9 +69,8 @@ class TaskHandler(Protocol):
         task: task_pb2.Task,
     ) -> any_pb2.Any | task_pb2.TaskErrorDetail:
         request = (
-            _as_run_program_request(
-                task.data,
-            )
+            _as_run_program_request(task.data)
+            or _as_ask_request(task.data)
             or _as_run_qua_calibration_request(task.data)
             or _as_display_results_request(task.data)
         )
@@ -78,6 +79,7 @@ class TaskHandler(Protocol):
                 agent_pb2.RunProgramRequest()
                 | agent_pb2.RunQuantumMachinesMixerCalibrationRequest()
                 | agent_pb2.DisplayResultsRequest()
+                | agent_pb2.AskRequest()
             ):
                 return _as_any_message(await self.handle(request))
             case None:
@@ -104,6 +106,17 @@ def _as_run_program_request(
     return request
 
 
+def _as_ask_request(
+    task_result: any_pb2.Any,
+) -> agent_pb2.AskRequest | None:
+    request = agent_pb2.AskRequest()
+    unpacked: bool = task_result.Unpack(request)  # type: ignore[reportUnknownMemberType]
+    if not unpacked:
+        return None
+
+    return request
+
+
 def _as_run_qua_calibration_request(
     task_result: any_pb2.Any,
 ) -> agent_pb2.RunQuantumMachinesMixerCalibrationRequest | None:
@@ -158,16 +171,22 @@ class Agent:
         Create a gRPC channel.
         """
         host = url.split(":")[0]
+        options = [
+            ("grpc.max_send_message_length", 1024 * 1024 * 50),  # 50MB
+            ("grpc.max_receive_message_length", 1024 * 1024 * 50),  # 50MB
+        ]
         if host in ["localhost", "127.0.0.1", "0.0.0.0", "::"]:
             channel = grpc.insecure_channel(
                 url,
                 interceptors=interceptors,
+                options=options,
             )
         else:
             channel = grpc.secure_channel(
                 url,
                 credentials=ssl_channel_credentials(),
                 interceptors=interceptors,
+                options=options,
             )
         return channel
 

boulderopalscaleupsdk/common/dtypes.py

@@ -28,7 +28,7 @@ from typing import Annotated, Any, Literal, Self
 
 import numpy as np
 from dateutil.parser import isoparse
-from pydantic import BeforeValidator, ConfigDict, Field, PlainSerializer, TypeAdapter
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, PlainSerializer, TypeAdapter
 from pydantic.dataclasses import dataclass
 
 GrpcMetadata = list[tuple[str, str | bytes]]
@@ -317,6 +317,36 @@ class JobHistorySortOrder(enum.Enum):
     CREATED_AT_ASC = 2
 
 
+class JobSummary(BaseModel):
+    id: str
+    name: str
+    device_name: str
+    session_id: str
+    created_at: ISO8601DatetimeUTCLike
+
+    def __str__(self):
+        return f'JobSummary(name="{self.name}", id="{self.id}")'
+
+
+class JobDataEntry(BaseModel):
+    message: str
+    created_at: ISO8601DatetimeUTCLike
+    dt: str
+    elapsed_time: str
+
+    class Config:
+        extra = "allow"
+
+
+class JobData(BaseModel):
+    id: str
+    name: str
+    session_id: str
+    created_at: ISO8601DatetimeUTCLike
+    device_name: str
+    data: list[JobDataEntry]
+
+
 DEFAULT_JOB_HISTORY_PAGE = 1
 DEFAULT_JOB_HISTORY_PAGE_SIZE = 10
 DEFAULT_JOB_HISTORY_SORT_ORDER = JobHistorySortOrder.CREATED_AT_DESC

boulderopalscaleupsdk/device/__init__.py

@@ -10,10 +10,3 @@
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS. See the
 # License for the specific language.
-
-__all__ = ["InvalidDevice", "InvalidDeviceComponent"]
-
-from boulderopalscaleupsdk.device.device import (
-    InvalidDevice,
-    InvalidDeviceComponent,
-)

boulderopalscaleupsdk/device/config_loader.py

@@ -34,6 +34,7 @@ class ProcessorArchitecture(str, Enum):
     Superconducting = "superconducting"
 
 
+# TODO: Remove this in the next release of SDK
 class DeviceInfo(BaseModel):
     controller_info: QBLOXControllerInfo | QuantumMachinesControllerInfo
     processor: SuperconductingProcessor  # | OtherSDKProcessorType

boulderopalscaleupsdk/device/controller/qblox.py

@@ -18,6 +18,7 @@ QBLOX Quantum Control Stack
 __all__ = (
     "DEFAULT_MODULE_CONSTRAINTS",
     "AcquisitionConfig",
+    "BitStrideArrayEncoding",
     "ChannelType",
     "ComplexChannel",
     "IndexedData",
@@ -40,15 +41,19 @@ __all__ = (
     "SequenceProgram",
     "SequencerAddr",
     "SequencerAddrType",
+    "SequencerResults",
+    "process_sequencer_output",
     "validate_channel",
 )
 
 import dataclasses
 import enum
+import math
 import re
 from dataclasses import dataclass
 from typing import Annotated, Any, ClassVar, Literal, Self, TypeVar
 
+import numpy as np
 from pydantic import BaseModel, BeforeValidator, Field, PlainSerializer, model_validator
 
 from boulderopalscaleupsdk.device.controller.base import Backend, ControllerType
@@ -252,18 +257,18 @@ ChannelType = RealChannel | ComplexChannel
 # ==================================================================================================
 # Controller information
 # ==================================================================================================
-class ElementConnection(BaseModel):  # pragma: no cover
+class PortConnection(BaseModel):  # pragma: no cover
     """
-    The connections involved for a control element.
+    The connections involved for a QPU port.
 
     Attributes
     ----------
     ch_out: ChannelType
-        The output channel that will signal towards the control element.
-    ch_in: ChannelType, optional
-        The input channel from which signals will be acquired from the element. This is optional, as
-        not all modules support acquisitions. If an input channel is specified, it must be located
-        on the same module as the output channel.
+        The output channel that will signal towards the QPU port
+    ch_in: ChannelType or None, optional
+        The input channel from which signals will be acquired from the QPU port. This is optional,
+        as not all modules support acquisitions. If an input channel is specified, it must be
+        located on the same module as the output channel.
 
     Notes
     -----
@@ -271,20 +276,21 @@ class ElementConnection(BaseModel):  # pragma: no cover
     direction is outwards from the control stack. The following diagram depicts a simple setup with
     the arrows indicating a control channel.
 
-        ┌────────┐           ┌────────────┐
-        │        │─── out ──►│Element: xy1│
-        │ QBLOX  │           └────────────┘
-        │ Stack  │           ┌────────────┐
-        │        │─── out ──►│Element: ro1│
-        │        │◄── in ────│            │
-        └────────┘           └────────────┘
+        ┌────────┐           ┌───────────────┐
+        │        │─── out ──►│ Port: p_xy1   │
+        │ QBLOX  │           └───────────────┘
+        │ Stack  │           ┌───────────────┐
+        │        │─── out ──►│ Port: p_flrr0 │
+        │        │◄── in ────│               │
+        └────────┘           └───────────────┘
+                                 QPU fridge
     """
 
     ch_out: ChannelType
     ch_in: ChannelType | None = None
 
     @model_validator(mode="after")
-    def validate_channels(self) -> "ElementConnection":
+    def validate_channels(self) -> "PortConnection":
         if self.ch_in is not None and self.ch_in.module != self.ch_out.module:
             raise ValueError("I/O channels for an element must be on the same module.")
         return self
@@ -304,38 +310,102 @@ class QBLOXControllerInfo(BaseModel):  # pragma: no cover
         The type of controller, which is always `ControllerType.QBLOX` for this class.
     modules: dict[ModuleAddrType, ModuleType]
         The modules connected to the QBLOX stack.
-    elements: dict[str, ElementConnection]
-        The addressable control elements for the stack.
+    port_config: dict[str, PortConnection]
+        The dictionary of ports with their types and addresses.
     """
 
     controller_type: Literal[ControllerType.QBLOX] = ControllerType.QBLOX
     modules: dict[ModuleAddrType, ModuleType]
-    elements: dict[str, ElementConnection]
+    port_config: dict[str, PortConnection]
 
 
 # ==================================================================================================
 # Instrument management
 # ==================================================================================================
 class SequencerParams(BaseModel):
-    nco_freq: float | None = Field(default=None, gt=0)
+    nco_freq: float | None = Field(default=None)
     gain_awg_path0: float | None = Field(default=None, ge=-1.0, le=1.0)
     offset_awg_path0: float | None = Field(default=None, ge=-1.0, le=1.0)
     gain_awg_path1: float | None = Field(default=None, ge=-1.0, le=1.0)
     offset_awg_path1: float | None = Field(default=None, ge=-1.0, le=1.0)
     marker_ovr_en: bool | None = Field(default=None)
-    marker_ovr_value: int | None = Field(default=None)
+    marker_ovr_value: int | None = Field(default=None, ge=0, le=15)
     mod_en_awg: bool | None = Field(default=None)
     demod_en_acq: bool | None = Field(default=None)
     sync_en: bool | None = Field(default=None)
     nco_prop_delay_comp_en: bool | None = Field(default=True)
-    integration_length_acq: int | None = Field(default=None)
+    integration_length_acq: int | None = Field(default=None, ge=4, le=16777212, multiple_of=4)
 
 
-class ModuleParams(BaseModel):
-    out0_in0_lo_freq: float | None = Field(default=None, gt=0)
-    out0_in0_lo_en: bool | None = Field(default=None)
+class QcmParams(BaseModel):
+    out0_offset: float | None = Field(default=None, ge=-2.5, le=2.5)
+    out1_offset: float | None = Field(default=None, ge=-2.5, le=2.5)
+    out2_offset: float | None = Field(default=None, ge=-2.5, le=2.5)
+    out3_offset: float | None = Field(default=None, ge=-2.5, le=2.5)
+
+    def update(self, other: Self) -> None:
+        if self == other:
+            return  # Nothing to do
+
+        self.out0_offset = pick_only_one_or_raise(self.out0_offset, other.out0_offset)
+        self.out1_offset = pick_only_one_or_raise(self.out1_offset, other.out1_offset)
+        self.out2_offset = pick_only_one_or_raise(self.out2_offset, other.out2_offset)
+        self.out3_offset = pick_only_one_or_raise(self.out3_offset, other.out3_offset)
+
+
+class QcmRfParams(BaseModel):
+    out0_att: int | None = Field(default=None, ge=0, le=60, multiple_of=2)
+    out1_att: int | None = Field(default=None, ge=0, le=60, multiple_of=2)
+
     out0_lo_freq: float | None = Field(default=None, gt=0)
     out0_lo_en: bool | None = Field(default=None)
+    out1_lo_freq: float | None = Field(default=None, gt=0)
+    out1_lo_en: bool | None = Field(default=None)
+
+    def update(self, other: Self) -> None:
+        if self == other:
+            return  # Nothing to do
+
+        self.out0_att = pick_only_one_or_raise(self.out0_att, other.out0_att)
+        self.out1_att = pick_only_one_or_raise(self.out1_att, other.out1_att)
+        self.out0_lo_freq = pick_only_one_or_raise(self.out0_lo_freq, other.out0_lo_freq)
+        self.out0_lo_en = pick_only_one_or_raise(self.out0_lo_en, other.out0_lo_en)
+        self.out1_lo_freq = pick_only_one_or_raise(self.out1_lo_freq, other.out1_lo_freq)
+        self.out1_lo_en = pick_only_one_or_raise(self.out1_lo_en, other.out1_lo_en)
+
+
+class QrmRfParams(BaseModel):
+    out0_att: int | None = Field(default=None, ge=0, le=60, multiple_of=2)
+
+    out0_in0_lo_freq: float | None = Field(default=None, gt=0)
+    out0_in0_lo_en: bool | None = Field(default=None)
+
+    def update(self, other: Self) -> None:
+        if self == other:
+            return  # Nothing to do
+
+        self.out0_att = pick_only_one_or_raise(self.out0_att, other.out0_att)
+        self.out0_in0_lo_freq = pick_only_one_or_raise(
+            self.out0_in0_lo_freq,
+            other.out0_in0_lo_freq,
+        )
+        self.out0_in0_lo_en = pick_only_one_or_raise(self.out0_in0_lo_en, other.out0_in0_lo_en)
+
+
+ModuleParams = QcmParams | QcmRfParams | QrmRfParams
+
+
+T0 = TypeVar("T0")
+
+
+def pick_only_one_or_raise(a: T0 | None, b: T0 | None) -> T0 | None:
+    if a == b:
+        return a
+    if a is None:
+        return b
+    if b is None:
+        return a
+    raise ValueError(f"Cannot resolve conflict between given parameters {a} and {b}!")
 
 
 # ==================================================================================================
@@ -373,6 +443,7 @@ class SequenceProgram(BaseModel):
     weights: dict[str, IndexedData] = {}
     acquisitions: dict[str, AcquisitionConfig] = {}
     acquisition_scopes: list[str] = []
+    acquisition_shapes: dict[str, tuple[int, ...]] = {}
     params: SequencerParams = SequencerParams()
     params_only: bool = False
 
@@ -408,7 +479,7 @@ class PreparedSequenceProgram(BaseModel):  # pragma: no cover
 
 
 class PreparedModule(BaseModel):
-    params: ModuleParams = ModuleParams()
+    params: ModuleParams
 
 
 class PreparedProgram(BaseModel):
@@ -417,6 +488,14 @@ class PreparedProgram(BaseModel):
     modules: dict[ModuleAddrType, PreparedModule]  # The set of modules this program will target.
     sequence_programs: dict[str, PreparedSequenceProgram]  # The individual element programs.
 
+    @property
+    def sequencers(self) -> dict[SequencerAddr, str]:
+        return {psp.sequencer_addr: name for name, psp in self.sequence_programs.items()}
+
+    def get_sequencer_program(self, seq_addr: SequencerAddr) -> SequenceProgram:
+        prog_name = self.sequencers[seq_addr]
+        return self.sequence_programs[prog_name].sequence_program
+
     def dumps(self) -> str:
         return self.model_dump_json()
 
@@ -428,6 +507,9 @@ class PreparedProgram(BaseModel):
 # ==================================================================================================
 # Results
 # ==================================================================================================
+MAX_ACQUISITION_BINS = 131072
+
+
 class OutputScopedAcquisitionData(BaseModel):  # pragma: no cover
     """
     Scoped acquisition data for a single path in `OutputScopedAcquisition`.
@@ -544,6 +626,121 @@ class OutputIndexedAcquisition(BaseModel):  # pragma: no cover
 OutputSequencerAcquisitions = dict[str, OutputIndexedAcquisition]  # pragma: no cover
 
 
+@dataclass
+class SequencerResults:
+    """
+    Sequencer results formatted as a complex signal.
+
+    The real component corresponds to results on path0, whilst the imaginary component corresponds
+    to the results on path1.
+    """
+
+    scopes: dict[str, np.ndarray]
+    bins: dict[str, np.ndarray]
+
+
+def process_sequencer_output(
+    program: SequenceProgram,
+    output: OutputSequencerAcquisitions,
+) -> SequencerResults:
+    """
+    Process the output from executing a sequencer into a simplified SequencerResults data structure.
+
+    Parameters
+    ----------
+    program: SequenceProgram
+        The corresponding program that was executed
+    output: OutputSequencerAcquisitions
+        The results of one sequencer's execution
+
+    Returns
+    -------
+    SequencerResults
+    """
+    bins = {}
+    scopes = {}
+    for acq_ref, acq_result in output.items():
+        acquisition = acq_result.acquisition
+
+        raw_bin = acquisition.bins.integration
+        shape = program.acquisition_shapes.get(acq_ref)
+        if shape is None or len(shape) == 1:
+            bins[acq_ref] = np.array(raw_bin.path0) + 1j * np.array(raw_bin.path1)
+        else:
+            bse = BitStrideArrayEncoding.from_desired(shape)
+            bins[acq_ref] = bse.decode(raw_bin.path0) + 1j * bse.decode(raw_bin.path1)
+
+        raw_scope = acquisition.scope
+        if acq_ref in program.acquisition_scopes:
+            scopes[acq_ref] = np.array(raw_scope.path0.data) + 1j * np.array(raw_scope.path1.data)
+
+    return SequencerResults(scopes=scopes, bins=bins)
+
+
+@dataclass
+class BitStrideArrayEncoding:
+    """
+    Encode a multi-dimensional array such that each dimensional index occupies an integer number of
+    bits (the bit-stride).
+
+    In this encoding, a linear index is calculated by left-shifting each element in the index by its
+    corresponding bit-stride:
+
+        linear_index = Σ (ii << bb) ∀ (ii, bb) ∈ zip(index, bit_strides)
+
+    Examples
+    --------
+    Given a desired_shape of (3, 5), the first index will have a bit-stride of 2 and the second
+    index will have a bit-stride of 3. To determine the linear index for a sample, we will use:
+
+        def linear_index(idx0: int, idx1: int) -> int:
+            return (idx0 << 2) + (idx1 << 3)
+
+    Note, the encoded data will occupy 2^2 * 2^3 samples and have (2^2 * 2^3 - 3 * 5) unused data
+    points.
+
+    >>> bse = BitStrideArrayEncoding.from_desired((3, 5))
+    >>> bse.encoded_shape
+    (4, 8)
+    >>> bse.bit_stride
+    (2, 3)
+    """
+
+    desired_shape: tuple[int, ...]
+    encoded_shape: tuple[int, ...]
+    bit_stride: tuple[int, ...]
+
+    @staticmethod
+    def _round_power2_32bit(val: int) -> int:
+        val -= 1
+        val |= val >> 1
+        val |= val >> 2
+        val |= val >> 4
+        val |= val >> 8
+        val |= val >> 16
+        val += 1
+        return val
+
+    @classmethod
+    def from_desired(cls, desired_shape: tuple[int, ...]) -> Self:
+        encoded_shape = tuple(
+            BitStrideArrayEncoding._round_power2_32bit(dim) for dim in desired_shape
+        )
+        # Right-most (most nested) dimension takes least significant bits!
+        exponents = tuple(int(math.log2(dim)) for dim in encoded_shape)
+        n_bits = sum(exponents)
+        bit_stride = tuple(n_bits - sum(exponents[: idx + 1]) for idx in range(len(exponents)))
+        return cls(
+            desired_shape=desired_shape,
+            encoded_shape=encoded_shape,
+            bit_stride=bit_stride,
+        )
+
+    def decode(self, values: list[float]) -> np.ndarray:
+        decoded = np.reshape(values, self.encoded_shape)
+        return decoded[tuple(slice(0, dim) for dim in self.desired_shape)]
+
+
 # ==================================================================================================
 # Utilities
 # ==================================================================================================

boulderopalscaleupsdk/device/defcal.py

@@ -11,52 +11,13 @@
 # distributed under the License is distributed on an "AS IS" BASIS. See the
 # License for the specific language.
 
-import re
-from typing import Annotated, Any, Literal
+from typing import Literal
 
-from pydantic import BeforeValidator, PlainSerializer, TypeAdapter
-from pydantic.dataclasses import dataclass
+from pydantic import BaseModel
 
-QubitAddr = tuple[int, ...]
-GateName = str
 
-_KEY_PATTERN = r"^.+#\d+(?:-\d+)*$"
-
-
-@dataclass(frozen=True)
-class DataKey:
-    gate: GateName
-    addr: QubitAddr
-
-    def as_tuple(self) -> tuple[GateName, QubitAddr]:
-        return (self.gate, self.addr)
-
-    @staticmethod
-    def from_string(value: Any) -> "DataKey | None":
-        match value:
-            case str():
-                if not re.match(_KEY_PATTERN, value):
-                    raise KeyError(f"invalid string for DataKey {value}")
-                gate, qubit_str = value.split("#", 1)
-                qubit_addr = tuple(int(q) for q in qubit_str.split("-"))
-                return DataKey(gate=gate, addr=qubit_addr)
-            case _:
-                return None
-
-    def serialize_as_string(self) -> str:
-        return f"{self.gate}#{'-'.join(str(i) for i in self.addr)}"
-
-
-DataKeyTypeAdapter = TypeAdapter(DataKey)
-DataKeyLike = Annotated[
-    DataKey,
-    BeforeValidator(lambda x: DataKey.from_string(x) or x),
-    PlainSerializer(lambda x: x.serialize_as_string(), return_type=str),
-]
-
-
-@dataclass
-class DefCalData:
+class DefCalData(BaseModel):
+    gate: str
+    addr: list[str]
     body: str
     status: Literal["calibrated", "uncalibrated"]
-    scope: Literal["public", "internal"]