feat(python): Constructors, iterators, and other utility methods have been added to make working with ResultData, RegisterMap, and others easier.

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = ["crates/*"]
+resolver = "2"
 
 [workspace.dependencies]
 qcs-api = "0.2.1"
@@ -27,3 +28,4 @@ pyo3 = { version = "0.17" }
 pyo3-asyncio = { version = "0.17", features = ["tokio-runtime"] }
 pyo3-build-config = { version = "0.17" }
 rigetti-pyo3 = { version = "0.1.0", features = ["complex"] }
+

crates/lib/Cargo.toml

@@ -29,15 +29,15 @@ qcs-api-client-common.workspace = true
 qcs-api-client-openapi.workspace = true
 qcs-api-client-grpc.workspace = true
 quil-rs.workspace = true
-reqwest = { version = "0.11.12", default-features = false, features = [
+reqwest = { version = "0.11.20", default-features = false, features = [
   "rustls-tls",
   "json",
 ] }
 rmp-serde = "1.1.1"
 serde = { version = "1.0.145", features = ["derive"] }
 serde_json.workspace = true
 thiserror.workspace = true
-tokio = { workspace = true, features = ["fs"] }
+tokio = { workspace = true, features = ["fs", "rt-multi-thread"] }
 toml = "0.7.3"
 tracing = { version = "0.1", optional = true, features = ["log"] }
 uuid = { version = "1.2.1", features = ["v4"] }

crates/lib/src/executable.rs

@@ -111,6 +111,7 @@ impl<'executable> Executable<'executable, '_> {
     /// 1. `quil` is a string slice representing the original program to be run. The returned
     ///     [`Executable`] will only live as long as this reference.
     #[must_use]
+    #[allow(clippy::missing_panics_doc)]
     pub fn from_quil<Quil: Into<Arc<str>>>(quil: Quil) -> Self {
         Self {
             quil: quil.into(),

crates/lib/src/execution_data.rs

@@ -83,7 +83,7 @@ pub enum RegisterMatrix {
 /// register.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[repr(transparent)]
-pub struct RegisterMap(HashMap<String, RegisterMatrix>);
+pub struct RegisterMap(pub HashMap<String, RegisterMatrix>);
 
 /// Errors that may occur when trying to build a [`RegisterMatrix`] from execution data
 #[allow(missing_docs)]

crates/python/.stubtest-allowlist

@@ -1,3 +1,3 @@
-qcs_sdk.qcs_sdk
 qcs_sdk._gather_diagnostics
 qcs_sdk.diagnostics
+qcs_sdk.qcs_sdk

crates/python/qcs_sdk/__init__.pyi

@@ -1,12 +1,12 @@
 import datetime
 from enum import Enum
-from typing import Dict, List, Sequence, Optional, Union, final
+from typing import Dict, List, Sequence, Optional, Union, final, Iterable, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
 
-from qcs_sdk.qpu import QPUResultData
-from qcs_sdk.qvm import QVMResultData
+from qcs_sdk.qpu import QPUResultData, RawQPUReadoutData
+from qcs_sdk.qvm import QVMResultData, RawQVMReadoutData
 from qcs_sdk.compiler.quilc import CompilerOpts
 
 from qcs_sdk.client import QCSClient as QCSClient
@@ -205,6 +205,11 @@ class RegisterMatrix:
     def from_real(inner: NDArray[np.float64]) -> "RegisterMatrix": ...
     @staticmethod
     def from_complex(inner: NDArray[np.complex128]) -> "RegisterMatrix": ...
+    def to_ndarray(self) -> Union[NDArray[np.complex128], NDArray[np.int64], NDArray[np.float64]]:
+        """
+        Get the RegisterMatrix as numpy ``ndarray``.
+        """
+        ...
 
 @final
 class RegisterMap:
@@ -213,6 +218,14 @@ class RegisterMap:
     def get_register_matrix(self, register_name: str) -> Optional[RegisterMatrix]:
         """Get the ``RegisterMatrix`` for the given register. Returns `None` if the register doesn't exist."""
         ...
+    def get(self, default: Optional[RegisterMatrix] = None) -> Optional[RegisterMatrix]: ...
+    def items(self) -> Iterable[Tuple[str, RegisterMatrix]]: ...
+    def keys(self) -> Iterable[str]: ...
+    def values(self) -> Iterable[RegisterMatrix]: ...
+    def __iter__(self) -> Iterable[str]: ...
+    def __getitem__(self, item: str) -> RegisterMatrix: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
 
 @final
 class ResultData:
@@ -261,6 +274,11 @@ class ResultData:
         - ``from_*``: wrap underlying values as this enum type.
     """
 
+    def __new__(cls, inner: Union[QPUResultData, QVMResultData]) -> "ResultData":
+        """
+        Create a new ResultData from either QVM or QPU result data.
+        """
+        ...
     def to_register_map(self) -> RegisterMap:
         """
         Convert ``ResultData`` from its inner representation as ``QVMResultData`` or
@@ -281,6 +299,11 @@ class ResultData:
         selects the last value per-shot based on the program that was run.
         """
         ...
+    def to_raw_readout_data(self) -> Union[RawQPUReadoutData, RawQVMReadoutData]:
+        """
+        Get the raw data returned from the QVM or QPU. See ``RawQPUReadoutData`` and
+        ``RawQVMReadoutData`` for more information.
+        """
     def inner(
         self,
     ) -> Union[QVMResultData, QPUResultData]:
@@ -299,6 +322,7 @@ class ResultData:
 
 @final
 class ExecutionData:
+    def __new__(cls, result_data: ResultData, duration: Optional[datetime.timedelta] = None): ...
     @property
     def result_data(self) -> ResultData: ...
     @result_data.setter
@@ -327,11 +351,15 @@ class RegisterData:
 
     """
 
+    def __new__(cls, inner: Union[List[List[int]], List[List[float]], List[List[complex]]]) -> "RegisterData": ...
     def inner(
         self,
     ) -> Union[List[List[int]], List[List[float]], List[List[complex]]]:
         """Returns the inner value."""
         ...
+    def as_ndarray(self) -> Union[NDArray[np.int64], NDArray[np.float64], NDArray[np.complex128]]:
+        """Returns the values as an ``ndarray``."""
+        ...
     def is_i8(self) -> bool: ...
     def is_i16(self) -> bool: ...
     def is_f64(self) -> bool: ...