qcs-sdk-python 0.29.0rc0__tar.gz → 0.30.0__tar.gz

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/Cargo.lock

@@ -126,13 +126,13 @@ dependencies = [
 
 [[package]]
 name = "async-trait"
-version = "0.1.89"
+version = "0.1.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.117",
+ "syn 3.0.4",
 ]
 
 [[package]]
@@ -3139,7 +3139,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
 dependencies = [
  "chrono",
- "indexmap 2.13.0",
  "inventory",
  "libc",
  "num-complex",
@@ -3302,7 +3301,7 @@ dependencies = [
  "pyo3",
  "pyo3-async-runtimes",
  "qcs-dependencies-client",
- "rigetti-pyo3 0.8.1",
+ "rigetti-pyo3",
  "serde",
  "serde_json",
  "thiserror 2.0.20",
@@ -3324,7 +3323,7 @@ dependencies = [
 
 [[package]]
 name = "qcs"
-version = "0.29.0-rc.0"
+version = "0.30.0"
 dependencies = [
  "assert2",
  "async-trait",
@@ -3364,7 +3363,7 @@ dependencies = [
  "qcs-dependencies-client",
  "quil-rs",
  "regex",
- "rigetti-pyo3 0.8.1",
+ "rigetti-pyo3",
  "rmp-serde",
  "rstest",
  "serde",
@@ -3407,7 +3406,7 @@ dependencies = [
  "pyo3-build-config",
  "pyo3-stub-gen",
  "qcs-dependencies-client",
- "rigetti-pyo3 0.8.1",
+ "rigetti-pyo3",
  "serde",
  "serde_json",
  "shellexpand",
@@ -3507,7 +3506,6 @@ version = "0.37.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab2279547bc521362a1ed413e1ad379de23d0efc4ae28f427a4184c8c390ee25"
 dependencies = [
- "anyhow",
  "approx",
  "derive-where",
  "derive_more",
@@ -3519,16 +3517,11 @@ dependencies = [
  "nom",
  "nom_locate",
  "num-complex",
- "numpy",
  "once_cell",
  "optipy 0.1.4",
  "pastey",
  "petgraph 0.6.5",
- "pyo3",
- "pyo3-build-config",
- "pyo3-stub-gen",
  "regex",
- "rigetti-pyo3 0.7.1",
  "serde",
  "statrs",
  "strum",
@@ -3929,20 +3922,6 @@ dependencies = [
  "tower-service",
 ]
 
-[[package]]
-name = "rigetti-pyo3"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213e90a6c913d2826aa2b14c0a267c0bd784e586f108319066fdd42834abf325"
-dependencies = [
- "indexmap 2.13.0",
- "itertools 0.14.0",
- "optipy 0.1.4",
- "pastey",
- "pyo3",
- "pyo3-stub-gen",
-]
-
 [[package]]
 name = "rigetti-pyo3"
 version = "0.8.1"

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qcs-sdk-python
-Version: 0.29.0rc0
+Version: 0.30.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.10
@@ -8,8 +8,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
-Requires-Dist: quil>=0.37.1,<0.38.0
-Requires-Dist: qcs-api-client-common>=0.19.0,<0.20.0
+Requires-Dist: qcs-api-client-common>=0.19.0,<0.27.0
 Summary: Python interface for the QCS Rust SDK
 Author-email: Rigetti QPU Software <qpu-software@rigetti.com>
 License: Apache-2.0

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.30.0 (2026-10-08)
+
+### Breaking Changes
+
+- remove quil as a dependency of qcs-sdk-python (#601)
+
+## 0.29.0 (2026-09-25)
+
+### Breaking Changes
+
+- ConnectionStrategy fields for more control over gateway use; use endpoint-ID for Gateway-bound jobs, when possible; remove now-superfluous endpoint_id methods and parameters (#597)
+
+## 0.29.0-rc.1 (2026-09-24)
+
+### Breaking Changes
+
+- put endpoint-ID in the connection-strategy itself; explicitly add the ability to connect to simulated endpoints via gateway; use endpoint-ID for Gateway-bound jobs, when possible
+
 ## 0.29.0-rc.0 (2026-09-23)
 
 ### Breaking Changes

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "qcs"
 description = "High level interface for running Quil on a QPU"
-version = "0.29.0-rc.0"
+version = "0.30.0"
 edition = "2018"
 license = "Apache-2.0"
 repository = "https://github.com/rigetti/qcs-sdk-rust"
@@ -36,13 +36,11 @@ python = [
     "dep:rigetti-pyo3",
     "experimental",
     "tracing-opentelemetry",
-    "quil-rs/python",
     "qcs-api-client-common/python",
 ]
 stubs = [
     "python",
     "dep:pyo3-stub-gen",
-    "quil-rs/stubs",
     "qcs-api-client-common/stubs",
     "pyo3-tracing-subscriber-build",
     "rigetti-pyo3/stubs",

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/python/stubtest-allowlist

@@ -13,3 +13,4 @@ qcs_sdk\.(_qcs_sdk\.)?compiler\.quilc\.CompilerOpts\.__new__
 qcs_sdk\.(_qcs_sdk\.)?Service\.(QCS|QPU|QUILC|QVM)
 qcs_sdk\.(_qcs_sdk\.)?qpu\.isa\.Family\.(ANKAA|ASPEN|FULL|NONE)
 qcs_sdk\.(_qcs_sdk\.)?qpu\.translation\.TranslationBackend\.(V1|V2)
+qcs_sdk\.(_qcs_sdk\.)?qpu\.api\.EndpointLiveness\.(LIVE_ONLY|LIVE_OR_SIMULATED|SIMULATED_ONLY)

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/src/compiler/python.rs

@@ -1,4 +1,5 @@
 use qcs_api_client_openapi::models::InstructionSetArchitecture;
+use quil_rs::quil::Quil;
 use rigetti_pyo3::{create_init_submodule, impl_repr, py_function_sync_async};
 use std::convert::TryFrom;
 
@@ -78,6 +79,18 @@ impl CompilerOpts {
     }
 }
 
+#[cfg_attr(feature = "stubs", gen_stub_pymethods)]
+#[pymethods]
+impl CompilationResult {
+    /// The compiled program, as a Quil string.
+    #[getter]
+    fn program(&self) -> PyResult<String> {
+        self.program
+            .to_quil()
+            .map_err(|err| errors::QuilcError::new_err(err.to_string()))
+    }
+}
+
 #[cfg_attr(feature = "stubs", gen_stub_pymethods)]
 #[pymethods]
 impl TargetDevice {

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/src/compiler/quilc.rs

@@ -60,12 +60,12 @@ pub trait Client {
 
 /// The result of compiling a Quil program to native quil with `quilc`
 #[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(not(feature = "python"), optipy::strip_pyo3)]
 #[cfg_attr(feature = "stubs", gen_stub_pyclass)]
 #[cfg_attr(
     feature = "python",
     pyo3::pyclass(
         module = "qcs_sdk._qcs_sdk.compiler.quilc",
-        get_all,
         frozen,
         from_py_object
     )
@@ -74,6 +74,7 @@ pub struct CompilationResult {
     /// The compiled program
     pub program: Program,
     /// Metadata about the compiled program
+    #[pyo3(get)]
     pub native_quil_metadata: Option<NativeQuilMetadata>,
 }
 

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/src/executable.rs

@@ -420,47 +420,6 @@ impl<'execution> Executable<'_, 'execution> {
         .map_err(Error::from)
     }
 
-    /// Compile the program and execute it on a QPU, waiting for results.
-    ///
-    /// # Arguments
-    /// 1. `quantum_processor_id`: The name of the QPU to run on. This parameter affects the
-    ///    lifetime of the [`Executable`]. The [`Executable`] will only live as long as the last
-    ///    parameter passed into this function.
-    ///
-    /// # Warning
-    ///
-    /// This function uses [`tokio::task::spawn_blocking`] internally. See the docs for that function
-    /// to avoid blocking shutdown of the runtime.
-    ///
-    /// # Returns
-    ///
-    /// An [`ExecutionResult`].
-    ///
-    /// # Errors
-    /// All errors are human readable by way of [`mod@thiserror`]. Some common errors are:
-    ///
-    /// 1. You are not authenticated for QCS
-    /// 1. Your credentials don't have an active reservation for the QPU you requested
-    /// 1. [quilc] was not running.
-    /// 1. The `quil` that this [`Executable`] was constructed with was invalid.
-    /// 1. Missing parameters that should be filled with [`Executable::with_parameter`]
-    ///
-    /// [quilc]: https://github.com/quil-lang/quilc
-    pub async fn execute_on_qpu_with_endpoint<S>(
-        &mut self,
-        quantum_processor_id: S,
-        endpoint_id: S,
-        translation_options: Option<TranslationOptions>,
-    ) -> ExecutionResult
-    where
-        S: Into<Cow<'execution, str>>,
-    {
-        let job_handle = self
-            .submit_to_qpu_with_endpoint(quantum_processor_id, endpoint_id, translation_options)
-            .await?;
-        self.retrieve_results(job_handle).await
-    }
-
     /// Compile the program and execute it on a QCS endpoint, waiting for results.
     ///
     /// # Arguments
@@ -560,31 +519,6 @@ impl<'execution> Executable<'_, 'execution> {
         Ok(job_handle)
     }
 
-    /// Compile and submit the program to a QCS endpoint, but do not wait for execution to complete.
-    ///
-    /// Call [`Executable::retrieve_results`] to wait for execution to complete and retrieve the
-    /// results.
-    ///
-    /// # Errors
-    ///
-    /// See [`Executable::execute_on_qpu`].
-    pub async fn submit_to_qpu_with_endpoint<S>(
-        &mut self,
-        quantum_processor_id: S,
-        endpoint_id: S,
-        translation_options: Option<TranslationOptions>,
-    ) -> Result<JobHandle<'execution>, Error>
-    where
-        S: Into<Cow<'execution, str>>,
-    {
-        let job_handle = self
-            .qpu_for_id(quantum_processor_id)
-            .await?
-            .submit_to_endpoint_id(&self.params, endpoint_id.into(), translation_options)
-            .await?;
-        Ok(job_handle)
-    }
-
     /// Cancel a job that has yet to begin executing.
     ///
     /// This action is *not* atomic, and will attempt to cancel a job even if it cannot be cancelled. A
@@ -754,7 +688,6 @@ impl From<qvm::Error> for Error {
 pub struct JobHandle<'executable> {
     job_id: JobId,
     quantum_processor_id: Cow<'executable, str>,
-    endpoint_id: Option<Cow<'executable, str>>,
     readout_map: HashMap<String, String>,
     execution_options: ExecutionOptions,
 }
@@ -764,7 +697,6 @@ impl<'a> JobHandle<'a> {
     pub(crate) fn new<S>(
         job_id: JobId,
         quantum_processor_id: S,
-        endpoint_id: Option<S>,
         readout_map: HashMap<String, String>,
         execution_options: ExecutionOptions,
     ) -> Self
@@ -774,7 +706,6 @@ impl<'a> JobHandle<'a> {
         Self {
             job_id,
             quantum_processor_id: quantum_processor_id.into(),
-            endpoint_id: endpoint_id.map(Into::into),
             readout_map,
             execution_options,
         }
@@ -792,11 +723,11 @@ impl<'a> JobHandle<'a> {
         &self.quantum_processor_id
     }
 
-    /// The ID of the endpoint to which the job was submitted, if it was submitted to a specific
-    /// endpoint (see [`Executable::submit_to_qpu_with_endpoint`]) rather than a quantum processor.
+    /// The ID of the endpoint to which the job was submitted, if the job's
+    /// [`ConnectionStrategy`](crate::qpu::api::ConnectionStrategy) specified one.
     #[must_use]
     pub fn endpoint_id(&self) -> Option<&str> {
-        self.endpoint_id.as_deref()
+        self.execution_options.connection_strategy().endpoint_id()
     }
 
     /// The readout map from source readout memory locations to the

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/src/python/executable.rs

@@ -234,160 +234,108 @@ impl PyExecutable {
 
     /// Compile the program and execute it on a QPU, waiting for results.
     ///
-    /// :param `endpoint_id`: execute the compiled program against an explicitly provided endpoint.
-    ///     If `None`, the default endpoint for the given `quantum_processor_id` is used.
+    /// :param `execution_options`: To target a specific endpoint, use a ``ConnectionStrategy``
+    ///     that carries an endpoint ID, e.g. ``ConnectionStrategy.EndpointId(...)``.
     ///
     /// :raises `ExecutionError`: If the job fails to execute.
-    #[pyo3(signature = (quantum_processor_id, endpoint_id = None, translation_options = None, execution_options = None))]
+    #[pyo3(signature = (quantum_processor_id, translation_options = None, execution_options = None))]
     pub fn execute_on_qpu(
         &self,
         py: Python<'_>,
         quantum_processor_id: String,
-        endpoint_id: Option<String>,
         translation_options: Option<TranslationOptions>,
         execution_options: Option<ExecutionOptions>,
     ) -> PyResult<ExecutionData> {
-        match endpoint_id {
-            Some(endpoint_id) => py_sync!(
-                py,
-                py_executable_data!(
-                    self,
-                    execute_on_qpu_with_endpoint,
-                    quantum_processor_id,
-                    endpoint_id,
-                    translation_options,
-                )
-            ),
-            None => py_sync!(
-                py,
-                py_executable_data!(
-                    self,
-                    execute_on_qpu,
-                    quantum_processor_id,
-                    translation_options,
-                    &execution_options.unwrap_or_default(),
-                )
-            ),
-        }
+        py_sync!(
+            py,
+            py_executable_data!(
+                self,
+                execute_on_qpu,
+                quantum_processor_id,
+                translation_options,
+                &execution_options.unwrap_or_default(),
+            )
+        )
     }
     /// Compile the program and execute it on a QPU, waiting for results
     /// (async analog of `Executable.execute_on_qpu`).
     ///
-    /// :param `endpoint_id`: execute the compiled program against an explicitly provided endpoint.
-    ///     If `None`, the default endpoint for the given `quantum_processor_id` is used.
+    /// :param `execution_options`: To target a specific endpoint, use a ``ConnectionStrategy``
+    ///     that carries an endpoint ID, e.g. ``ConnectionStrategy.EndpointId(...)``.
     ///
     /// :raises `ExecutionError`: If the job fails to execute.
-    #[pyo3(signature = (quantum_processor_id, endpoint_id = None, translation_options = None, execution_options = None))]
+    #[pyo3(signature = (quantum_processor_id, translation_options = None, execution_options = None))]
     pub fn execute_on_qpu_async<'py>(
         &self,
         py: Python<'py>,
         quantum_processor_id: String,
-        endpoint_id: Option<String>,
         translation_options: Option<TranslationOptions>,
         execution_options: Option<ExecutionOptions>,
     ) -> PyResult<Awaitable<'py, ExecutionData>> {
-        match endpoint_id {
-            Some(endpoint_id) => pyo3_async_runtimes::tokio::future_into_py(
-                py,
-                py_executable_data!(
-                    self,
-                    execute_on_qpu_with_endpoint,
-                    quantum_processor_id,
-                    endpoint_id,
-                    translation_options,
-                ),
-            ),
-            None => pyo3_async_runtimes::tokio::future_into_py(
-                py,
-                py_executable_data!(
-                    self,
-                    execute_on_qpu,
-                    quantum_processor_id,
-                    translation_options,
-                    &execution_options.unwrap_or_default(),
-                ),
+        pyo3_async_runtimes::tokio::future_into_py(
+            py,
+            py_executable_data!(
+                self,
+                execute_on_qpu,
+                quantum_processor_id,
+                translation_options,
+                &execution_options.unwrap_or_default(),
             ),
-        }
+        )
         .map(Into::into)
     }
 
     /// Compile the program and execute it on a QPU, without waiting for results.
     ///
-    /// :param `endpoint_id`: execute the compiled program against an explicitly provided endpoint.
-    ///     If `None`, the default endpoint for the given `quantum_processor_id` is used.
+    /// :param `execution_options`: To target a specific endpoint, use a ``ConnectionStrategy``
+    ///     that carries an endpoint ID, e.g. ``ConnectionStrategy.EndpointId(...)``.
     ///
     /// :raises `ExecutionError`: If the job fails to execute.
-    #[pyo3(signature = (quantum_processor_id, endpoint_id = None, translation_options = None, execution_options = None))]
+    #[pyo3(signature = (quantum_processor_id, translation_options = None, execution_options = None))]
     pub fn submit_to_qpu(
         &self,
         py: Python<'_>,
         quantum_processor_id: String,
-        endpoint_id: Option<String>,
         translation_options: Option<TranslationOptions>,
         execution_options: Option<ExecutionOptions>,
     ) -> PyResult<PyJobHandle> {
-        match endpoint_id {
-            Some(endpoint_id) => py_sync!(
-                py,
-                py_job_handle!(
-                    self,
-                    submit_to_qpu_with_endpoint,
-                    quantum_processor_id,
-                    endpoint_id,
-                    translation_options,
-                )
-            ),
-            None => py_sync!(
-                py,
-                py_job_handle!(
-                    self,
-                    submit_to_qpu,
-                    quantum_processor_id,
-                    translation_options,
-                    &execution_options.unwrap_or_default(),
-                )
-            ),
-        }
+        py_sync!(
+            py,
+            py_job_handle!(
+                self,
+                submit_to_qpu,
+                quantum_processor_id,
+                translation_options,
+                &execution_options.unwrap_or_default(),
+            )
+        )
     }
 
     /// Compile the program and execute it on a QPU, without waiting for results
     /// (async analog of `Executable.submit_to_qpu`).
     ///
-    /// :param `endpoint_id`: execute the compiled program against an explicitly provided endpoint.
-    ///     If `None`, the default endpoint for the given `quantum_processor_id` is used.
+    /// :param `execution_options`: To target a specific endpoint, use a ``ConnectionStrategy``
+    ///     that carries an endpoint ID, e.g. ``ConnectionStrategy.EndpointId(...)``.
     ///
     /// :raises `ExecutionError`: If the job fails to execute.
-    #[pyo3(signature = (quantum_processor_id, endpoint_id = None, translation_options = None, execution_options = None))]
+    #[pyo3(signature = (quantum_processor_id, translation_options = None, execution_options = None))]
     pub fn submit_to_qpu_async<'py>(
         &self,
         py: Python<'py>,
         quantum_processor_id: String,
-        endpoint_id: Option<String>,
         translation_options: Option<TranslationOptions>,
         execution_options: Option<ExecutionOptions>,
     ) -> PyResult<Awaitable<'py, PyJobHandle>> {
-        match endpoint_id {
-            Some(endpoint_id) => pyo3_async_runtimes::tokio::future_into_py(
-                py,
-                py_job_handle!(
-                    self,
-                    submit_to_qpu_with_endpoint,
-                    quantum_processor_id,
-                    endpoint_id,
-                    translation_options,
-                ),
-            ),
-            None => pyo3_async_runtimes::tokio::future_into_py(
-                py,
-                py_job_handle!(
-                    self,
-                    submit_to_qpu,
-                    quantum_processor_id,
-                    translation_options,
-                    &execution_options.unwrap_or_default(),
-                ),
+        pyo3_async_runtimes::tokio::future_into_py(
+            py,
+            py_job_handle!(
+                self,
+                submit_to_qpu,
+                quantum_processor_id,
+                translation_options,
+                &execution_options.unwrap_or_default(),
             ),
-        }
+        )
         .map(Into::into)
     }
 

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.30.0}/crates/lib/src/python/mod.rs

@@ -110,7 +110,7 @@ fn init_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
 mod stubs {
     use pyo3_stub_gen::{
         define_stub_info_gatherer, derive::gen_type_alias_from_python, exclude_from_all,
-        export_verbatim, module_doc, reexport_module_members, Result, StubInfo,
+        export_verbatim, reexport_module_members, Result, StubInfo,
     };
     use std::path::Path;
 
@@ -166,9 +166,7 @@ mod stubs {
     reexport_module_members!("qcs_sdk.qvm.api" from "qcs_sdk._qcs_sdk.qvm.api");
 
     reexport_module_members!("qcs_sdk._qcs_sdk.client" from "qcs_api_client_common._qcs_api_client_common"; "configuration");
-    reexport_module_members!("qcs_sdk._qcs_sdk.compiler.quilc" from "quil._quil"; "program");
     exclude_from_all!("qcs_sdk._qcs_sdk.client", "configuration");
-    exclude_from_all!("qcs_sdk._qcs_sdk.compiler.quilc", "program");
 
     reexport_module_members!("qcs_sdk" from "qcs_sdk._qcs_sdk.client"; "QCSClient");
 
@@ -178,8 +176,6 @@ mod stubs {
     export_verbatim!("qcs_sdk._qcs_sdk", "_gather_diagnostics");
     export_verbatim!("qcs_sdk._qcs_sdk", "__version__");
 
-    module_doc!("quil._quil.validation", "");
-
     define_stub_info_gatherer!(internal_stub_info);
 
     /// Gather stub information to generate stub files.
@@ -188,12 +184,11 @@ mod stubs {
         let mut stubs = StubInfo::from_pyproject_toml(manifest_dir.join("pyproject.toml"))?;
 
         // `pyo3_stub_gen` gathers declarations from every linked crate, so dependencies that
-        // define their own Python packages (`quil-rs` and `qcs-api-client-common`) contribute
-        // their modules here too. Generation rejects any non-empty module outside this
-        // package's module path, and writing files for them would shadow the real, installed
-        // packages, so drop them. The stubs refer to foreign types by their private paths
-        // (`quil._quil.program.Program`), since resolving the public alias needs the foreign
-        // module to still be present at generation time.
+        // define their own Python packages (`qcs-api-client-common`) contribute their modules
+        // here too. Generation rejects any non-empty module outside this package's module path,
+        // and writing files for them would shadow the real, installed packages, so drop them.
+        // The stubs refer to foreign types by their private paths, since resolving the public
+        // alias needs the foreign module to still be present at generation time.
         stubs
             .modules
             .retain(|name, _| name == "qcs_sdk" || name.starts_with("qcs_sdk."));