feat: Shot count is now represented as an unsigned 32-bit, up from

16-bit

crates/lib/src/compiler/libquil.rs

@@ -174,7 +174,7 @@ mod test {
     use qcs_api_client_openapi::models::InstructionSetArchitecture;
     use quil_rs::quil::Quil;
     use regex::Regex;
-    use std::{collections::HashMap, fs::File, num::NonZeroU16};
+    use std::{collections::HashMap, fs::File, num::NonZeroU32};
 
     const EXPECTED_H0_OUTPUT: &str = "MEASURE 0\n";
 
@@ -231,7 +231,7 @@ MEASURE 1 ro[1]
         let mut results = qvm::Execution::new(&output.program.to_quil_or_debug())
             .unwrap()
             .run(
-                NonZeroU16::new(10).expect("value is non-zero"),
+                NonZeroU32::new(10).expect("value is non-zero"),
                 [("ro".to_string(), AddressRequest::IncludeAll)]
                     .iter()
                     .cloned()

crates/lib/src/compiler/quilc.rs

@@ -345,7 +345,7 @@ mod tests {
     use qcs_api_client_openapi::models::InstructionSetArchitecture;
     use quil_rs::quil::Quil;
     use regex::Regex;
-    use std::{fs::File, num::NonZeroU16};
+    use std::{fs::File, num::NonZeroU32};
 
     const EXPECTED_H0_OUTPUT: &str = "MEASURE 0\n";
 
@@ -399,7 +399,7 @@ MEASURE 1 ro[1]
         let mut results = qvm::Execution::new(&output.program.to_quil_or_debug())
             .unwrap()
             .run(
-                NonZeroU16::new(10).expect("value is non-zero"),
+                NonZeroU32::new(10).expect("value is non-zero"),
                 [("ro".to_string(), AddressRequest::IncludeAll)]
                     .iter()
                     .cloned()

crates/lib/src/executable.rs

@@ -3,7 +3,7 @@
 
 use std::borrow::Cow;
 use std::collections::HashMap;
-use std::num::NonZeroU16;
+use std::num::NonZeroU32;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -42,10 +42,10 @@ use quil_rs::program::ProgramError;
 ///
 /// #[tokio::main]
 /// async fn main() {
-///     use std::num::NonZeroU16;
+///     use std::num::NonZeroU32;
 ///     use qcs::qvm;
 ///     let qvm_client = qvm::http::HttpClient::from(&Qcs::load());
-///     let mut result = Executable::from_quil(PROGRAM).with_qcs_client(Qcs::default()).with_shots(NonZeroU16::new(4).unwrap()).execute_on_qvm(&qvm_client).await.unwrap();
+///     let mut result = Executable::from_quil(PROGRAM).with_qcs_client(Qcs::default()).with_shots(NonZeroU32::new(4).unwrap()).execute_on_qvm(&qvm_client).await.unwrap();
 ///     // "ro" is the only source read from by default if you don't specify a .read_from()
 ///
 ///     // We first convert the readout data to a [`RegisterMap`] to get a mapping of registers
@@ -87,7 +87,7 @@ use quil_rs::program::ProgramError;
 #[allow(missing_debug_implementations)]
 pub struct Executable<'executable, 'execution> {
     quil: Arc<str>,
-    shots: NonZeroU16,
+    shots: NonZeroU32,
     readout_memory_region_names: Option<Vec<Cow<'executable, str>>>,
     params: Parameters,
     qcs_client: Option<Arc<Qcs>>,
@@ -119,7 +119,7 @@ impl<'executable> Executable<'executable, '_> {
     pub fn from_quil<Quil: Into<Arc<str>>>(quil: Quil) -> Self {
         Self {
             quil: quil.into(),
-            shots: NonZeroU16::new(1).expect("value is non-zero"),
+            shots: NonZeroU32::new(1).expect("value is non-zero"),
             readout_memory_region_names: None,
             params: Parameters::new(),
             compiler_options: CompilerOpts::default(),
@@ -318,7 +318,7 @@ pub type ExecutionResult = Result<execution_data::ExecutionData, Error>;
 impl Executable<'_, '_> {
     /// Specify a number of times to run the program for each execution. Defaults to 1 run or "shot".
     #[must_use]
-    pub fn with_shots(mut self, shots: NonZeroU16) -> Self {
+    pub fn with_shots(mut self, shots: NonZeroU32) -> Self {
         self.shots = shots;
         self
     }
@@ -827,7 +827,7 @@ mod describe_get_config {
 #[cfg(feature = "manual-tests")]
 mod describe_qpu_for_id {
     use assert2::let_assert;
-    use std::num::NonZeroU16;
+    use std::num::NonZeroU32;
 
     use crate::compiler::quilc::CompilerOpts;
     use crate::compiler::rpcq;
@@ -857,7 +857,7 @@ mod describe_qpu_for_id {
     #[tokio::test]
     async fn it_loads_cached_version() {
         let mut exe = Executable::from_quil("").with_quilc_client(Some(quilc_client()));
-        let shots = NonZeroU16::new(17).expect("value is non-zero");
+        let shots = NonZeroU32::new(17).expect("value is non-zero");
         exe.shots = shots;
         exe.qpu = Some(
             qpu::Execution::new(
@@ -879,7 +879,7 @@ mod describe_qpu_for_id {
 
     #[tokio::test]
     async fn it_creates_new_after_shot_change() {
-        let original_shots = NonZeroU16::new(23).expect("value is non-zero");
+        let original_shots = NonZeroU32::new(23).expect("value is non-zero");
         let mut exe = Executable::from_quil("")
             .with_quilc_client(Some(quilc_client()))
             .with_shots(original_shots);
@@ -889,7 +889,7 @@ mod describe_qpu_for_id {
 
         // Cache so we can verify cache is not used.
         exe.qpu = Some(qpu);
-        let new_shots = NonZeroU16::new(32).expect("value is non-zero");
+        let new_shots = NonZeroU32::new(32).expect("value is non-zero");
         exe = exe.with_shots(new_shots);
         let qpu = exe.qpu_for_id("Aspen-9").await.unwrap();
 

crates/lib/src/qpu/execution.rs

@@ -2,7 +2,7 @@
 
 use std::borrow::Cow;
 use std::convert::TryFrom;
-use std::num::NonZeroU16;
+use std::num::NonZeroU32;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -35,7 +35,7 @@ use crate::compiler::quilc::{self, CompilerOpts, TargetDevice};
 pub(crate) struct Execution<'a> {
     program: Program,
     pub(crate) quantum_processor_id: Cow<'a, str>,
-    pub(crate) shots: NonZeroU16,
+    pub(crate) shots: NonZeroU32,
     client: Arc<Qcs>,
 }
 
@@ -119,7 +119,7 @@ impl<'a> Execution<'a> {
     ///     for the QPU or that there is a bug in this library.
     pub(crate) async fn new(
         quil: Arc<str>,
-        shots: NonZeroU16,
+        shots: NonZeroU32,
         quantum_processor_id: Cow<'a, str>,
         client: Arc<Qcs>,
         quilc_client: Option<Arc<dyn quilc::Client + Send + Sync>>,

crates/lib/src/qvm/execution.rs

@@ -1,5 +1,5 @@
 use std::str::FromStr;
-use std::{collections::HashMap, num::NonZeroU16};
+use std::{collections::HashMap, num::NonZeroU32};
 
 use quil_rs::Program;
 
@@ -54,7 +54,7 @@ impl Execution {
     /// Missing parameters, extra parameters, or parameters of the wrong type will all cause errors.
     pub(crate) async fn run<C: Client + ?Sized>(
         &self,
-        shots: NonZeroU16,
+        shots: NonZeroU32,
         addresses: HashMap<String, AddressRequest>,
         params: &Parameters,
         client: &C,
@@ -76,7 +76,7 @@ impl Execution {
 
 #[cfg(test)]
 mod describe_execution {
-    use std::{collections::HashMap, num::NonZeroU16};
+    use std::{collections::HashMap, num::NonZeroU32};
 
     use super::{Execution, Parameters};
     use crate::{client::Qcs, qvm};
@@ -95,7 +95,7 @@ mod describe_execution {
 
         let result = exe
             .run(
-                NonZeroU16::new(1).expect("value is non-zero"),
+                NonZeroU32::new(1).expect("value is non-zero"),
                 HashMap::new(),
                 &params,
                 &qvm_client(),
@@ -117,7 +117,7 @@ mod describe_execution {
 
         let result = exe
             .run(
-                NonZeroU16::new(1).expect("value is non-zero"),
+                NonZeroU32::new(1).expect("value is non-zero"),
                 HashMap::new(),
                 &params,
                 &qvm_client(),

crates/lib/src/qvm/http.rs

@@ -1,7 +1,7 @@
 //! This module provides types and functions for making HTTP-based API calls to the QVM.
 //! Consider [`super::run_program`] for higher level access to the QVM that allows
 //! for running parameterized programs.
-use std::{collections::HashMap, num::NonZeroU16};
+use std::{collections::HashMap, num::NonZeroU32};
 
 use reqwest::Response;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -62,7 +62,7 @@ pub struct MultishotRequest {
     /// The memory regions to include in the response.
     pub addresses: HashMap<String, AddressRequest>,
     /// The number of trials ("shots") to run.
-    pub trials: NonZeroU16,
+    pub trials: NonZeroU32,
     /// Simulated measurement noise for the X, Y, and Z axes.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub measurement_noise: Option<(f64, f64, f64)>,
@@ -109,7 +109,7 @@ impl MultishotRequest {
     #[must_use]
     pub fn new(
         compiled_quil: String,
-        trials: NonZeroU16,
+        trials: NonZeroU32,
         addresses: HashMap<String, AddressRequest>,
         measurement_noise: Option<(f64, f64, f64)>,
         gate_noise: Option<(f64, f64, f64)>,
@@ -142,7 +142,7 @@ pub struct MultishotMeasureRequest {
     /// The Quil program to run.
     pub compiled_quil: String,
     /// The number of trials ("shots") to run the program.
-    pub trials: NonZeroU16,
+    pub trials: NonZeroU32,
     /// Qubits to measure
     pub qubits: Vec<u64>,
     /// Simulated measurement noise for the X, Y, and Z axes.
@@ -163,7 +163,7 @@ impl MultishotMeasureRequest {
     #[must_use]
     pub fn new(
         compiled_quil: String,
-        trials: NonZeroU16,
+        trials: NonZeroU32,
         qubits: &[u64],
         measurement_noise: Option<(f64, f64, f64)>,
         gate_noise: Option<(f64, f64, f64)>,
@@ -389,7 +389,7 @@ where
 
 #[cfg(test)]
 mod describe_request {
-    use std::{collections::HashMap, num::NonZeroU16};
+    use std::{collections::HashMap, num::NonZeroU32};
 
     use crate::qvm::http::AddressRequest;
 
@@ -400,7 +400,7 @@ mod describe_request {
         let program = "H 0";
         let request = MultishotRequest::new(
             program.to_string(),
-            NonZeroU16::new(1).expect("value is non-zero"),
+            NonZeroU32::new(1).expect("value is non-zero"),
             HashMap::new(),
             None,
             None,
@@ -413,7 +413,7 @@ mod describe_request {
     fn it_uses_kebab_case_for_json() {
         let request = MultishotRequest::new(
             "H 0".to_string(),
-            NonZeroU16::new(10).expect("value is non-zero"),
+            NonZeroU32::new(10).expect("value is non-zero"),
             [("ro".to_string(), AddressRequest::IncludeAll)]
                 .iter()
                 .cloned()

crates/lib/src/qvm/mod.rs

@@ -1,7 +1,7 @@
 //! This module contains all the functionality for running Quil programs on a QVM. Specifically,
 //! the [`Execution`] struct in this module.
 
-use std::{collections::HashMap, num::NonZeroU16, str::FromStr, sync::Arc, time::Duration};
+use std::{collections::HashMap, num::NonZeroU32, str::FromStr, sync::Arc, time::Duration};
 
 use quil_rs::{
     instruction::{ArithmeticOperand, Instruction, MemoryReference, Move},
@@ -129,7 +129,7 @@ impl QvmResultData {
 #[allow(clippy::too_many_arguments)]
 pub async fn run<C: Client + Send + Sync + ?Sized>(
     quil: &str,
-    shots: NonZeroU16,
+    shots: NonZeroU32,
     addresses: HashMap<String, AddressRequest>,
     params: &Parameters,
     measurement_noise: Option<(f64, f64, f64)>,
@@ -160,7 +160,7 @@ pub async fn run<C: Client + Send + Sync + ?Sized>(
 #[allow(clippy::too_many_arguments)]
 pub async fn run_program<C: Client + ?Sized>(
     program: &Program,
-    shots: NonZeroU16,
+    shots: NonZeroU32,
     addresses: HashMap<String, AddressRequest>,
     params: &Parameters,
     measurement_noise: Option<(f64, f64, f64)>,

crates/lib/tests/basic_qvm.rs

@@ -1,7 +1,7 @@
 //! These are the integration tests for [`qcs::Executable::execute_on_qvm`].
 //! In order to run them, QVM's web server must be running at localhost:5000.
 
-use std::num::NonZeroU16;
+use std::num::NonZeroU32;
 
 use qcs::{client::Qcs, compiler::rpcq, qvm, Executable};
 
@@ -29,7 +29,7 @@ async fn qvm_client() -> qvm::http::HttpClient {
 
 #[tokio::test]
 async fn test_bell_state() {
-    let shots: NonZeroU16 = NonZeroU16::new(10).expect("value is non-zero");
+    let shots: NonZeroU32 = NonZeroU32::new(10).expect("value is non-zero");
 
     let data = Executable::from_quil(PROGRAM)
         .with_quilc_client(Some(quilc_client().await))

crates/lib/tests/mocked_qpu.rs

@@ -76,7 +76,7 @@ async fn run_bell_state(connection_strategy: ConnectionStrategy) {
         .expect("should be valid execution options");
     let result = Executable::from_quil(BELL_STATE)
         .with_quilc_client(Some(quilc_client().await))
-        .with_shots(std::num::NonZeroU16::new(2).expect("value is non-zero"))
+        .with_shots(std::num::NonZeroU32::new(2).expect("value is non-zero"))
         .execute_on_qpu(QPU_ID, None, &execution_options_direct_access)
         .await
         .expect("Failed to run program that should be successful");

crates/lib/tests/qvm_api.rs

@@ -1,7 +1,7 @@
 //! Integration tests for the [`qcs::qvm::http`] module. Requires the QVM
 //! web server to be running.
 
-use std::{collections::HashMap, num::NonZeroU16};
+use std::{collections::HashMap, num::NonZeroU32};
 
 use qcs::{
     client::Qcs,
@@ -49,7 +49,7 @@ async fn test_get_version_info<C: qvm::Client>(client: C) {
 async fn test_run<C: qvm::Client>(client: C) {
     let request = http::MultishotRequest::new(
         PROGRAM.to_string(),
-        NonZeroU16::new(2).expect("value is non-zero"),
+        NonZeroU32::new(2).expect("value is non-zero"),
         HashMap::from([("ro".to_string(), http::AddressRequest::IncludeAll)]),
         Some((0.1, 0.5, 0.4)),
         Some((0.1, 0.5, 0.4)),
@@ -74,7 +74,7 @@ async fn test_run<C: qvm::Client>(client: C) {
 async fn test_run_and_measure<C: qvm::Client>(client: C) {
     let request = http::MultishotMeasureRequest::new(
         PROGRAM.to_string(),
-        NonZeroU16::new(5).expect("value is non-zero"),
+        NonZeroU32::new(5).expect("value is non-zero"),
         &[0, 1],
         Some((0.1, 0.5, 0.4)),
         Some((0.1, 0.5, 0.4)),

crates/python/src/executable.rs

@@ -1,4 +1,4 @@
-use std::{num::NonZeroU16, sync::Arc};
+use std::{num::NonZeroU32, sync::Arc};
 
 use opentelemetry::trace::FutureExt;
 use pyo3::{pyclass, FromPyObject};
@@ -108,7 +108,7 @@ impl PyExecutable {
         quil: String,
         registers: Vec<String>,
         parameters: Vec<PyParameter>,
-        #[pyo3(from_py_with = "crate::from_py::optional_non_zero_u16")] shots: Option<NonZeroU16>,
+        #[pyo3(from_py_with = "crate::from_py::optional_non_zero_u16")] shots: Option<NonZeroU32>,
         quilc_client: Option<PyQuilcClient>,
         compiler_options: Option<PyCompilerOpts>,
     ) -> Self {

crates/python/src/from_py.rs

@@ -1,19 +1,19 @@
-use std::num::NonZeroU16;
+use std::num::NonZeroU32;
 
 use pyo3::{exceptions::PyValueError, PyAny, PyResult};
 
-pub(crate) fn try_from_u16_to_non_zero_u16(int: u16) -> PyResult<NonZeroU16> {
-    NonZeroU16::new(int).ok_or(PyValueError::new_err("value must be non-zero"))
+pub(crate) fn try_from_u32_to_non_zero_u32(int: u32) -> PyResult<NonZeroU32> {
+    NonZeroU32::new(int).ok_or(PyValueError::new_err("value must be non-zero"))
 }
-pub(crate) fn non_zero_u16(obj: &PyAny) -> PyResult<NonZeroU16> {
-    let value: u16 = obj.extract()?;
-    try_from_u16_to_non_zero_u16(value)
+pub(crate) fn non_zero_u32(obj: &PyAny) -> PyResult<NonZeroU32> {
+    let value: u32 = obj.extract()?;
+    try_from_u32_to_non_zero_u32(value)
 }
 
-pub(crate) fn optional_non_zero_u16(obj: &PyAny) -> PyResult<Option<NonZeroU16>> {
-    let value: Option<u16> = obj.extract()?;
+pub(crate) fn optional_non_zero_u32(obj: &PyAny) -> PyResult<Option<NonZeroU32>> {
+    let value: Option<u32> = obj.extract()?;
     match value {
         None => Ok(None),
-        Some(int) => Ok(Some(try_from_u16_to_non_zero_u16(int)?)),
+        Some(int) => Ok(Some(try_from_u32_to_non_zero_u32(int)?)),
     }
 }