feat!: implement Python wrappers for the full Rust API

crates/lib/Cargo.toml

@@ -19,7 +19,7 @@ futures = "0.3.24"
 indexmap = "1.9.1"
 lazy_static = "1.4.0"
 log = "0.4.17"
-num = "0.4.0"
+num = { version = "0.4.0", features = ["serde"] }
 qcs-api = "0.2.1"
 qcs-api-client-common = "0.2.7"
 qcs-api-client-openapi = "0.3.8"

crates/lib/src/api.rs

@@ -3,6 +3,7 @@
 
 use std::{collections::HashMap, str::FromStr};
 
+use num::complex::Complex32;
 use qcs_api_client_grpc::{
     models::controller::{readout_values, ControllerJobExecutionResult},
     services::controller::{
@@ -55,7 +56,7 @@ pub enum RewriteArithmeticError {
 
 /// The result of a call to [`rewrite_arithmetic`] which provides the
 /// information necessary to later patch-in memory values to a compiled program.
-#[derive(Debug, Serialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct RewriteArithmeticResult {
     /// The rewritten program
     pub program: String,
@@ -193,17 +194,13 @@ pub fn build_patch_values(
         .iter()
         .map(|expr| Expression::from_str(expr))
         .collect::<Result<_, _>>()
-        .map_err(|e| format!("Unable to interpret recalculation table: {:?}", e))?;
+        .map_err(|e| format!("Unable to interpret recalculation table: {e:?}"))?;
     rewrite_arithmetic::get_substitutions(&substitutions, memory)
 }
 
-/// A convenience type that describes a Complex-64 value whose real
-/// and imaginary parts of both f32.
-pub type Complex64 = [f32; 2];
-
 /// Data from an individual register. Each variant contains a vector with the expected data type
 /// where each value in the vector corresponds to a shot.
-#[derive(Debug, PartialEq, Serialize)]
+#[derive(Clone, Debug, PartialEq, Serialize)]
 #[serde(untagged)] // Don't include the discriminant name in serialized output.
 pub enum Register {
     /// A register of 64-bit floating point numbers
@@ -213,7 +210,10 @@ pub enum Register {
     /// A register of 32-bit integers
     I32(Vec<i32>),
     /// A register of 64-bit complex numbers
-    Complex64(Vec<Complex64>),
+    ///
+    /// This type is called `Complex64` because the entire complex number takes 64 bits,
+    /// while the inner type is called `Complex32` because both components are `f32`.
+    Complex64(Vec<Complex32>),
     /// A register of 8-bit integers (bytes)
     I8(Vec<i8>),
 }
@@ -224,15 +224,15 @@ impl From<qpu::runner::Register> for Register {
             runner::Register::F64(f) => Register::F64(f),
             runner::Register::I16(i) => Register::I16(i),
             runner::Register::Complex32(c) => {
-                Register::Complex64(c.iter().map(|c| [c.re, c.im]).collect())
+                Register::Complex64(c.iter().map(|c| Complex32::new(c.re, c.im)).collect())
             }
             runner::Register::I8(i) => Register::I8(i),
         }
     }
 }
 
 /// The execution readout data from a particular memory location.
-#[derive(Debug, Serialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct ExecutionResult {
     shape: Vec<usize>,
     data: Register,
@@ -248,7 +248,7 @@ impl From<readout_values::Values> for ExecutionResult {
                 data: Register::Complex64(
                     c.values
                         .iter()
-                        .map(|c| [c.real.unwrap_or(0.0), c.imaginary.unwrap_or(0.0)])
+                        .map(|c| Complex32::new(c.real.unwrap_or(0.0), c.imaginary.unwrap_or(0.0)))
                         .collect(),
                 ),
             },
@@ -262,7 +262,7 @@ impl From<readout_values::Values> for ExecutionResult {
 }
 
 /// Execution readout data for all memory locations.
-#[derive(Debug, Serialize)]
+#[derive(Clone, Debug, Serialize)]
 pub struct ExecutionResults {
     buffers: HashMap<String, ExecutionResult>,
     execution_duration_microseconds: Option<u64>,