qcs-sdk-python 0.16.4rc1__tar.gz → 0.16.5rc0__tar.gz

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/Cargo.lock

@@ -2054,7 +2054,7 @@ dependencies = [
 
 [[package]]
 name = "qcs"
-version = "0.20.5-rc.1"
+version = "0.20.6-rc.0"
 dependencies = [
  "assert2",
  "async-trait",
@@ -2183,7 +2183,7 @@ dependencies = [
 
 [[package]]
 name = "qcs-sdk-python"
-version = "0.16.4-rc.1"
+version = "0.16.5-rc.0"
 dependencies = [
  "async-trait",
  "numpy",
@@ -2213,8 +2213,8 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quil-rs"
-version = "0.22.5"
-source = "git+https://github.com/rigetti/quil-rs?tag=quil-py/v0.6.5#bfee2c882b402c7b14b921af2ca346b639378f4b"
+version = "0.22.6"
+source = "git+https://github.com/rigetti/quil-rs?tag=quil-py/v0.6.6#b406c3e98a974e391d16236a75b8e6cbea102f2f"
 dependencies = [
  "approx",
  "indexmap 1.9.3",

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/Cargo.toml

@@ -15,7 +15,7 @@ tokio = "1.34.0"
 # be a `quil-py` tag and should match the version used in `crates/python/pyproject.toml`
 # The version must also be specified in order to publish to crates.io. Cargo enforces
 # that the specified version is the same as the version in the git repository.
-quil-rs = { version = "0.22.5", git = "https://github.com/rigetti/quil-rs", tag = "quil-py/v0.6.5" }
+quil-rs = { version = "0.22.6", git = "https://github.com/rigetti/quil-rs", tag = "quil-py/v0.6.6" }
 
 # ndarray is used by the `qcs` crate, but it is also used in the `python` crate via a
 # re-export through the numpy crate. They should be updated as a pair to keep both

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qcs-sdk-python
-Version: 0.16.4rc1
+Version: 0.16.5rc0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.8
@@ -8,7 +8,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Operating System :: OS Independent
-Requires-Dist: quil ==0.6.5
+Requires-Dist: quil ==0.6.6
 Summary: Python interface for the QCS Rust SDK
 Keywords: pyquil,SDK,Rigetti,Quil,Quantum
 Author-email: Rigetti Computing <softapps@rigetti.com>, Mark Skilbeck <mark.skilbeck@rigetti.com>, Marquess Valdez <mvaldez@rigetti.com>, Randall Fulton <rfulton@rigetti.com>

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.20.6-rc.0
+
+### Features
+
+- Jobs that have yet to begin executing can be cancelled. (#438)
+
+## 0.20.5
+
+### Features
+
+- instrument pyo3-opentelemetry (#391)
+
+### Fixes
+
+- bump quil-rs versions (#435)
+
+## 0.20.5-rc.2
+
+### Features
+
+- instrument pyo3-opentelemetry (#391)
+
+### Fixes
+
+- bump quil-rs versions (#435)
+
 ## 0.20.5-rc.1
 
 ### Features

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "qcs"
 description = "High level interface for running Quil on a QPU"
-version = "0.20.5-rc.1"
+version = "0.20.6-rc.0"
 edition = "2018"
 license = "Apache-2.0"
 repository = "https://github.com/rigetti/qcs-sdk-rust"

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/src/executable.rs

@@ -587,6 +587,20 @@ impl<'execution> Executable<'_, 'execution> {
         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
+    /// job can be cancelled only if it has not yet started executing.
+    ///
+    /// Success response indicates only that the request was received. Cancellation is not guaranteed,
+    /// as it is based on job state at the time of cancellation, and is completed on a best effort
+    /// basis.
+    pub async fn cancel_qpu_job(&mut self, job_handle: JobHandle<'execution>) -> Result<(), Error> {
+        let quantum_processor_id = job_handle.quantum_processor_id.to_string();
+        let qpu = self.qpu_for_id(quantum_processor_id).await?;
+        Ok(qpu.cancel_job(job_handle).await?)
+    }
+
     /// Wait for the results of a job submitted via [`Executable::submit_to_qpu`] to complete.
     ///
     /// # Errors

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/src/qpu/api.rs

@@ -16,8 +16,9 @@ use qcs_api_client_grpc::{
     },
     services::controller::{
         controller_client::ControllerClient, execute_controller_job_request,
-        get_controller_job_results_request, ExecuteControllerJobRequest,
-        ExecutionOptions as InnerApiExecutionOptions, GetControllerJobResultsRequest,
+        get_controller_job_results_request, CancelControllerJobsRequest,
+        ExecuteControllerJobRequest, ExecutionOptions as InnerApiExecutionOptions,
+        GetControllerJobResultsRequest,
     },
 };
 pub use qcs_api_client_openapi::apis::Error as OpenApiError;
@@ -125,6 +126,79 @@ pub async fn submit(
         .ok_or_else(|| GrpcClientError::ResponseEmpty("Job Execution ID".into()))?)
 }
 
+/// Cancel all given jobs that have yet to begin executing.
+///
+/// This action is *not* atomic, and will attempt to cancel every job even when some jobs cannot be
+/// cancelled. A job can be cancelled only if it has not yet started executing.
+///
+/// Success response indicates only that the request was received. Cancellation is not guaranteed,
+/// as it is based on job state at the time of cancellation, and is completed on a best effort
+/// basis.
+///
+/// # Arguments
+/// * `quantum_processor_id` - The quantum processor to execute the job on. This parameter
+///      is required unless using [`ConnectionStrategy::EndpointId`] in `execution_options`
+///      to target a specific endpoint ID.
+/// * `job_ids` - The [`JobId`]s to cancel.
+/// * `client` - The [`Qcs`] client to use.
+/// * `execution_options` - The [`ExecutionOptions`] to use. If the connection strategy used
+///       is [`ConnectionStrategy::EndpointId`] then direct access to that endpoint
+///       overrides the `quantum_processor_id` parameter.
+pub async fn cancel_jobs(
+    job_ids: Vec<JobId>,
+    quantum_processor_id: Option<&str>,
+    client: &Qcs,
+    execution_options: &ExecutionOptions,
+) -> Result<(), QpuApiError> {
+    let request = CancelControllerJobsRequest {
+        job_ids: job_ids.into_iter().map(|id| id.0).collect(),
+    };
+
+    let mut controller_client = execution_options
+        .get_controller_client(client, quantum_processor_id)
+        .await?;
+
+    controller_client
+        .cancel_controller_jobs(request)
+        .await
+        .map_err(GrpcClientError::RequestFailed)?;
+
+    Ok(())
+}
+
+/// 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
+/// job can be cancelled only if it has not yet started executing.
+///
+/// Success response indicates only that the request was received. Cancellation is not guaranteed,
+/// as it is based on job state at the time of cancellation, and is completed on a best effort
+/// basis.
+///
+/// # Arguments
+/// * `quantum_processor_id` - The quantum processor to execute the job on. This parameter is
+///      required unless using [`ConnectionStrategy::EndpointId`] in `execution_options` to target
+///      a specific endpoint ID.
+/// * `job_ids` - The [`JobId`]s to cancel.
+/// * `client` - The [`Qcs`] client to use.
+/// * `execution_options` - The [`ExecutionOptions`] to use. If the connection strategy used is
+///      [`ConnectionStrategy::EndpointId`] then direct access to that endpoint overrides the
+///      `quantum_processor_id` parameter.
+pub async fn cancel_job(
+    job_id: JobId,
+    quantum_processor_id: Option<&str>,
+    client: &Qcs,
+    execution_options: &ExecutionOptions,
+) -> Result<(), QpuApiError> {
+    cancel_jobs(
+        vec![job_id],
+        quantum_processor_id,
+        client,
+        execution_options,
+    )
+    .await
+}
+
 /// Fetch results from QPU job execution.
 ///
 /// # Arguments

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/src/qpu/execution.rs

@@ -259,6 +259,17 @@ impl<'a> Execution<'a> {
         ))
     }
 
+    pub(crate) async fn cancel_job(&self, job_handle: JobHandle<'a>) -> Result<(), Error> {
+        crate::qpu::api::cancel_job(
+            job_handle.job_id(),
+            Some(job_handle.quantum_processor_id()),
+            self.client.as_ref(),
+            job_handle.execution_options(),
+        )
+        .await
+        .map_err(Error::from)
+    }
+
     pub(crate) async fn retrieve_results(
         &self,
         job_handle: JobHandle<'a>,

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/lib/src/qpu/translation.rs

@@ -174,6 +174,7 @@ impl TranslationOptions {
         options
     }
 
+    #[allow(dead_code)]
     fn ensure_backend_v1(&mut self) -> Result<&mut BackendV1Options, TranslationBackendMismatch> {
         if matches!(self.backend(), None | Some(TranslationBackend::V1(_))) {
             Ok(self.with_backend_v1())

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/python/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.16.5-rc.0
+
+### Features
+
+- Jobs that have yet to begin executing can be cancelled. (#438)
+
+## 0.16.4
+
+### Features
+
+- instrument pyo3-opentelemetry (#391)
+
+### Fixes
+
+- bump quil-rs versions (#435)
+
+## 0.16.4-rc.2
+
+### Features
+
+- instrument pyo3-opentelemetry (#391)
+
+### Fixes
+
+- bump quil-rs versions (#435)
+
 ## 0.16.4-rc.1
 
 ### Features

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/python/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "qcs-sdk-python"
 description = "Python bindings to qcs-sdk-rust"
-version = "0.16.4-rc.1"
+version = "0.16.5-rc.0"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/rigetti/qcs-sdk-rust"

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/python/qcs_sdk/qpu/api.pyi

@@ -8,8 +8,8 @@ class SubmissionError(RuntimeError):
 
     ...
 
-class RetrieveResultsError(RuntimeError):
-    """There was a problem retrieving program execution results from QCS."""
+class QpuApiError(RuntimeError):
+    """An error occured while interacting with the QPU API."""
 
     ...
 
@@ -133,6 +133,107 @@ async def submit_async(
     """
     ...
 
+def cancel_job(
+    job_id: str,
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    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
+    job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param job_id: The job ID to cancel.
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+async def cancel_job_async(
+    job_id: str,
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel a job that has yet to begin executing (async analog of `cancel_job`).
+
+    This action is *not* atomic, and will attempt to cancel a job even if it cannot be cancelled. A
+    job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param job_id: The job ID to cancel.
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+def cancel_jobs(
+    job_ids: List[str],
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel all given jobs that have yet to begin executing.
+
+    This action is *not* atomic, and will attempt to cancel every job even when some jobs cannot be
+    cancelled. A job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :param job_ids: The job IDs to cancel.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+async def cancel_jobs_async(
+    job_ids: List[str],
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel all given jobs that have yet to begin executing (async analog of `cancel_jobs`).
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :param job_ids: The job IDs to cancel.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
 def retrieve_results(
     job_id: str,
     quantum_processor_id: Optional[str] = None,
@@ -151,7 +252,7 @@ def retrieve_results(
     :returns: results from execution.
 
     :raises LoadClientError: If there is an issue loading the QCS Client configuration.
-    :raises SubmissionError: If there was a problem during program execution.
+    :raises QpuApiError: If there was a problem retrieving the results.
     """
     ...
 
@@ -174,7 +275,7 @@ async def retrieve_results_async(
     :returns: results from execution.
 
     :raises LoadClientError: If there is an issue loading the QCS Client configuration.
-    :raises SubmissionError: If there was a problem during program execution.
+    :raises QpuApiError: If there was a problem retrieving the results.
     """
     ...
 

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/crates/python/src/qpu/api.rs

@@ -42,11 +42,15 @@ create_init_submodule! {
     ],
     errors: [
         SubmissionError,
-        RetrieveResultsError
+        QpuApiError
     ],
     funcs: [
         py_submit,
         py_submit_async,
+        py_cancel_job,
+        py_cancel_job_async,
+        py_cancel_jobs,
+        py_cancel_jobs_async,
         py_retrieve_results,
         py_retrieve_results_async
     ],
@@ -107,13 +111,8 @@ py_function_sync_async! {
     }
 }
 
-wrap_error!(RustRetrieveResultsError(qcs::qpu::api::QpuApiError));
-py_wrap_error!(
-    runner,
-    RustRetrieveResultsError,
-    RetrieveResultsError,
-    PyRuntimeError
-);
+wrap_error!(RustQpuApiError(qcs::qpu::api::QpuApiError));
+py_wrap_error!(runner, RustQpuApiError, QpuApiError, PyRuntimeError);
 
 /// Variants of data vectors within a single ExecutionResult.
 #[derive(Clone, Debug)]
@@ -276,6 +275,54 @@ impl ExecutionResults {
     }
 }
 
+py_function_sync_async! {
+    #[pyfunction]
+    #[pyo3(signature = (job_ids, quantum_processor_id = None, client = None, execution_options = None))]
+    async fn cancel_jobs(
+        job_ids: Vec<String>,
+        quantum_processor_id: Option<String>,
+        client: Option<PyQcsClient>,
+        execution_options: Option<PyExecutionOptions>,
+    ) -> PyResult<()> {
+        let client = PyQcsClient::get_or_create_client(client).await;
+
+        qcs::qpu::api::cancel_jobs(
+            job_ids.into_iter().map(|id| id.into()).collect(),
+            quantum_processor_id.as_deref(),
+            &client,
+            execution_options.unwrap_or_default().as_inner()
+        )
+        .await
+        .map_err(RustQpuApiError::from).map_err(RustQpuApiError::to_py_err)?;
+
+        Ok(())
+    }
+}
+
+py_function_sync_async! {
+    #[pyfunction]
+    #[pyo3(signature = (job_id, quantum_processor_id = None, client = None, execution_options = None))]
+    async fn cancel_job(
+        job_id: String,
+        quantum_processor_id: Option<String>,
+        client: Option<PyQcsClient>,
+        execution_options: Option<PyExecutionOptions>,
+    ) -> PyResult<()> {
+        let client = PyQcsClient::get_or_create_client(client).await;
+
+        qcs::qpu::api::cancel_job(
+            job_id.into(),
+            quantum_processor_id.as_deref(),
+            &client,
+            execution_options.unwrap_or_default().as_inner()
+        )
+        .await
+        .map_err(RustQpuApiError::from).map_err(RustQpuApiError::to_py_err)?;
+
+        Ok(())
+    }
+}
+
 py_function_sync_async! {
     #[pyfunction]
     #[pyo3(signature = (job_id, quantum_processor_id = None, client = None, execution_options = None))]
@@ -289,8 +336,8 @@ py_function_sync_async! {
 
         let results = qcs::qpu::api::retrieve_results(job_id.into(), quantum_processor_id.as_deref(), &client, execution_options.unwrap_or_default().as_inner())
             .await
-            .map_err(RustRetrieveResultsError::from)
-            .map_err(RustRetrieveResultsError::to_py_err)?;
+            .map_err(RustQpuApiError::from)
+            .map_err(RustQpuApiError::to_py_err)?;
 
         Python::with_gil(|py| {
             ExecutionResults::from_controller_job_execution_result(py, results)

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/pyproject.toml

@@ -1,7 +1,7 @@
 # This is the metadata Maturin uploads to PyPI on publish
 [project]
 name = "qcs-sdk-python"
-version = "0.16.4-rc.1"
+version = "0.16.5-rc.0"
 description = "Python interface for the QCS Rust SDK"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -20,13 +20,13 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Operating System :: OS Independent",
 ]
-dependencies = ["quil==0.6.5"]
+dependencies = ["quil==0.6.6"]
 
 # PEP 621 specifies the [project] table as the source for project metadata. However, Poetry only supports [tool.poetry]
 # We can remove this table once this issue is resolved: https://github.com/python-poetry/poetry/issues/3332
 [tool.poetry]
 name = "qcs-sdk-python"
-version = "0.16.4-rc.1"
+version = "0.16.5-rc.0"
 description = "Python interface for the QCS Rust SDK"
 readme = "README.md"
 authors = [

{qcs_sdk_python-0.16.4rc1 → qcs_sdk_python-0.16.5rc0}/qcs_sdk/qpu/api.pyi

@@ -8,8 +8,8 @@ class SubmissionError(RuntimeError):
 
     ...
 
-class RetrieveResultsError(RuntimeError):
-    """There was a problem retrieving program execution results from QCS."""
+class QpuApiError(RuntimeError):
+    """An error occured while interacting with the QPU API."""
 
     ...
 
@@ -133,6 +133,107 @@ async def submit_async(
     """
     ...
 
+def cancel_job(
+    job_id: str,
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    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
+    job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param job_id: The job ID to cancel.
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+async def cancel_job_async(
+    job_id: str,
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel a job that has yet to begin executing (async analog of `cancel_job`).
+
+    This action is *not* atomic, and will attempt to cancel a job even if it cannot be cancelled. A
+    job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param job_id: The job ID to cancel.
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+def cancel_jobs(
+    job_ids: List[str],
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel all given jobs that have yet to begin executing.
+
+    This action is *not* atomic, and will attempt to cancel every job even when some jobs cannot be
+    cancelled. A job can be cancelled only if it has not yet started executing.
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :param job_ids: The job IDs to cancel.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
+async def cancel_jobs_async(
+    job_ids: List[str],
+    quantum_processor_id: Optional[str] = None,
+    client: Optional[QCSClient] = None,
+    execution_options: Optional[ExecutionOptions] = None,
+):
+    """
+    Cancel all given jobs that have yet to begin executing (async analog of `cancel_jobs`).
+
+    Success response indicates only that the request was received. Cancellation is not guaranteed,
+    as it is based on job state at the time of cancellation, and is completed on a best effort
+    basis.
+
+    :param quantum_processor_id: The quantum processor to execute the job on. This parameter is
+         required unless using the `ConnectionStrategy.endpoint_id()` execution option.
+    :param job_ids: The job IDs to cancel.
+    :client: - The `QCSClient` to use.
+    :execution_options: The `ExecutionOptions` to use. If the connection strategy used is
+         ConnectionStrategy.endpoint_id() then direct access to that endpoint overrides the
+         `quantum_processor_id` parameter.
+    """
+    ...
+
 def retrieve_results(
     job_id: str,
     quantum_processor_id: Optional[str] = None,
@@ -151,7 +252,7 @@ def retrieve_results(
     :returns: results from execution.
 
     :raises LoadClientError: If there is an issue loading the QCS Client configuration.
-    :raises SubmissionError: If there was a problem during program execution.
+    :raises QpuApiError: If there was a problem retrieving the results.
     """
     ...
 
@@ -174,7 +275,7 @@ async def retrieve_results_async(
     :returns: results from execution.
 
     :raises LoadClientError: If there is an issue loading the QCS Client configuration.
-    :raises SubmissionError: If there was a problem during program execution.
+    :raises QpuApiError: If there was a problem retrieving the results.
     """
     ...