qcs-sdk-python 0.29.0rc0__tar.gz → 0.29.0rc1__tar.gz

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

@@ -3324,7 +3324,7 @@ dependencies = [
 
 [[package]]
 name = "qcs"
-version = "0.29.0-rc.0"
+version = "0.29.0-rc.1"
 dependencies = [
  "assert2",
  "async-trait",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qcs-sdk-python
-Version: 0.29.0rc0
+Version: 0.29.0rc1
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3.10

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

@@ -1,3 +1,9 @@
+## 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.29.0rc1}/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.29.0-rc.1"
 edition = "2018"
 license = "Apache-2.0"
 repository = "https://github.com/rigetti/qcs-sdk-rust"

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/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.29.0rc1}/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.29.0rc1}/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.29.0rc1}/crates/lib/src/qpu/api/mod.rs

@@ -273,7 +273,13 @@ pub async fn cancel_job(
     client: &Qcs,
     execution_options: &ExecutionOptions,
 ) -> Result<(), QpuApiError> {
-    cancel_jobs(vec![job_id], quantum_processor_id, client, execution_options).await
+    cancel_jobs(
+        vec![job_id],
+        quantum_processor_id,
+        client,
+        execution_options,
+    )
+    .await
 }
 
 #[expect(clippy::missing_errors_doc)]
@@ -554,6 +560,7 @@ pub enum EndpointLiveness {
 
 /// The connection strategy to use when submitting and retrieving jobs from a QPU.
 #[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(not(feature = "python"), optipy::strip_pyo3)]
 #[cfg_attr(feature = "stubs", gen_stub_pyclass_complex_enum)]
 #[cfg_attr(
     feature = "python",
@@ -561,6 +568,7 @@ pub enum EndpointLiveness {
 )]
 pub enum ConnectionStrategy {
     /// Connect through the publicly accessible gateway.
+    #[pyo3(constructor = (liveness=EndpointLiveness::default(), endpoint_id=None))]
     Gateway {
         /// Whether the gateway should route to live hardware, simulated hardware, or either.
         liveness: EndpointLiveness,
@@ -578,6 +586,18 @@ pub enum ConnectionStrategy {
     EndpointAddress(String),
 }
 
+impl ConnectionStrategy {
+    /// The endpoint ID carried by this strategy, if any.
+    #[must_use]
+    pub fn endpoint_id(&self) -> Option<&str> {
+        match self {
+            Self::EndpointId(endpoint_id) => Some(endpoint_id),
+            Self::Gateway { endpoint_id, .. } => endpoint_id.as_deref(),
+            Self::DirectAccess() | Self::EndpointAddress(_) => None,
+        }
+    }
+}
+
 impl Default for ConnectionStrategy {
     fn default() -> Self {
         Self::Gateway {
@@ -599,13 +619,8 @@ fn resolve_target<T>(
     by_endpoint_id: impl FnOnce(String) -> T,
     by_quantum_processor_id: impl FnOnce(String) -> T,
 ) -> Result<Option<T>, QpuApiError> {
-    let strategy_endpoint_id = match connection_strategy {
-        ConnectionStrategy::EndpointId(endpoint_id) => Some(endpoint_id),
-        ConnectionStrategy::Gateway { endpoint_id, .. } => endpoint_id.as_ref(),
-        ConnectionStrategy::DirectAccess() | ConnectionStrategy::EndpointAddress(_) => None,
-    };
-    if let Some(endpoint_id) = strategy_endpoint_id {
-        return Ok(Some(by_endpoint_id(endpoint_id.clone())));
+    if let Some(endpoint_id) = connection_strategy.endpoint_id() {
+        return Ok(Some(by_endpoint_id(endpoint_id.to_owned())));
     }
     if let Some(quantum_processor_id) = quantum_processor_id {
         return Ok(Some(by_quantum_processor_id(
@@ -698,7 +713,9 @@ pub trait ExecutionTarget<'a> {
         client: &Qcs,
         quantum_processor_id: Option<&str>,
     ) -> Result<ControllerClient<GrpcConnection>, QpuApiError> {
-        let service = self.get_qpu_grpc_connection(client, quantum_processor_id).await?;
+        let service = self
+            .get_qpu_grpc_connection(client, quantum_processor_id)
+            .await?;
         Ok(ControllerClient::new(service)
             .max_encoding_message_size(MAX_CONTROLLER_OUTBOUND_REQUEST_SIZE)
             // do not limit the received response size, although practically the limit is 4Gb due

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/crates/lib/src/qpu/api/python.rs

@@ -436,6 +436,12 @@ impl ConnectionStrategy {
         Self::default()
     }
 
+    fn get_endpoint_id(&self) -> PyResult<String> {
+        self.endpoint_id().map(ToOwned::to_owned).ok_or_else(|| {
+            errors::QpuApiError::new_err("ConnectionStrategy does not have an endpoint ID")
+        })
+    }
+
     #[gen_stub(override_return_type(
         type_repr = "tuple[str] | tuple[EndpointLiveness, str | None] | tuple[()]"
     ))]

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

@@ -18,9 +18,7 @@ use crate::execution_data::{MemoryReferenceParseError, ResultData};
 use crate::qpu::translation::translate;
 use crate::{ExecutionData, JobHandle};
 
-use super::api::{
-    retrieve_results, submit, ConnectionStrategy, ExecutionOptions, ExecutionOptionsBuilder,
-};
+use super::api::{retrieve_results, submit, ExecutionOptions};
 use super::translation::{EncryptedTranslationResult, TranslationOptions};
 use super::QpuResultData;
 use super::{get_isa, GetIsaError};
@@ -180,54 +178,11 @@ impl<'a> Execution<'a> {
     ) -> Result<JobHandle<'a>, Error> {
         tracing::debug!(quantum_processor_id=%self.quantum_processor_id, "submitting job to QPU");
 
-        self.submit_to_target(
-            params,
-            None,
-            Some(&self.quantum_processor_id.clone()),
-            translation_options,
-            execution_options,
-        )
-        .await
-    }
-
-    /// Run on specific QCS endpoint and wait for the results.
-    pub(crate) async fn submit_to_endpoint_id<S>(
-        &mut self,
-        params: &Parameters,
-        endpoint_id: S,
-        translation_options: Option<TranslationOptions>,
-    ) -> Result<JobHandle<'a>, Error>
-    where
-        S: Into<Cow<'a, str>>,
-    {
-        let endpoint_id: Cow<'a, str> = endpoint_id.into();
-        let connection_strategy = ConnectionStrategy::EndpointId(endpoint_id.clone().into_owned());
-        self.submit_to_target(
-            params,
-            Some(&endpoint_id),
-            None,
-            translation_options,
-            &ExecutionOptionsBuilder::default()
-                .connection_strategy(connection_strategy)
-                .build()
-                .expect("valid execution options"),
-        )
-        .await
-    }
-
-    async fn submit_to_target(
-        &mut self,
-        params: &Parameters,
-        endpoint_id: Option<&str>,
-        quantum_processor_id: Option<&str>,
-        translation_options: Option<TranslationOptions>,
-        execution_options: &ExecutionOptions,
-    ) -> Result<JobHandle<'a>, Error> {
         let EncryptedTranslationResult { job, readout_map } =
             self.translate(translation_options).await?;
 
         let job_id = submit(
-            quantum_processor_id,
+            Some(&self.quantum_processor_id),
             job,
             params,
             self.client.as_ref(),
@@ -238,7 +193,6 @@ impl<'a> Execution<'a> {
         Ok(JobHandle::new(
             job_id,
             self.quantum_processor_id.to_string(),
-            endpoint_id.map(ToOwned::to_owned),
             readout_map,
             execution_options.clone(),
         ))

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/crates/lib/uv.lock

@@ -855,7 +855,7 @@ wheels = [
 
 [[package]]
 name = "qcs-sdk-python"
-version = "0.28.0"
+version = "0.29.0rc0"
 source = { virtual = "." }
 dependencies = [
     { name = "qcs-api-client-common" },

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qcs-sdk-python"
-version = "0.29.0-rc.0"
+version = "0.29.0-rc.1"
 description = "Python interface for the QCS Rust SDK"
 authors = [
     { name = "Rigetti QPU Software", email = "qpu-software@rigetti.com" },

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/python/qcs_sdk/_qcs_sdk/__init__.pyi

@@ -149,22 +149,20 @@ class Executable:
     def execute_on_qpu(
         self,
         quantum_processor_id: builtins.str,
-        endpoint_id: typing.Optional[builtins.str] = None,
         translation_options: typing.Optional[translation.TranslationOptions] = None,
         execution_options: typing.Optional[api.ExecutionOptions] = None,
     ) -> ExecutionData:
         r"""
         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.
         """
     def execute_on_qpu_async(
         self,
         quantum_processor_id: builtins.str,
-        endpoint_id: typing.Optional[builtins.str] = None,
         translation_options: typing.Optional[translation.TranslationOptions] = None,
         execution_options: typing.Optional[api.ExecutionOptions] = None,
     ) -> collections.abc.Awaitable[ExecutionData]:
@@ -172,8 +170,8 @@ class Executable:
         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.
         """
@@ -206,22 +204,20 @@ class Executable:
     def submit_to_qpu(
         self,
         quantum_processor_id: builtins.str,
-        endpoint_id: typing.Optional[builtins.str] = None,
         translation_options: typing.Optional[translation.TranslationOptions] = None,
         execution_options: typing.Optional[api.ExecutionOptions] = None,
     ) -> JobHandle:
         r"""
         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.
         """
     def submit_to_qpu_async(
         self,
         quantum_processor_id: builtins.str,
-        endpoint_id: typing.Optional[builtins.str] = None,
         translation_options: typing.Optional[translation.TranslationOptions] = None,
         execution_options: typing.Optional[api.ExecutionOptions] = None,
     ) -> collections.abc.Awaitable[JobHandle]:
@@ -229,8 +225,8 @@ class Executable:
         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.
         """

{qcs_sdk_python-0.29.0rc0 → qcs_sdk_python-0.29.0rc1}/python/qcs_sdk/_qcs_sdk/qpu/api/__init__.pyi

@@ -129,6 +129,7 @@ class ConnectionStrategy:
         """
     @staticmethod
     def default() -> ConnectionStrategy: ...
+    def get_endpoint_id(self) -> builtins.str: ...
     @typing.final
     class DirectAccess(ConnectionStrategy):
         r"""
@@ -190,7 +191,9 @@ class ConnectionStrategy:
             Whether the gateway should route to live hardware, simulated hardware, or either.
             """
         def __new__(
-            cls, liveness: EndpointLiveness, endpoint_id: typing.Optional[builtins.str]
+            cls,
+            liveness: EndpointLiveness = EndpointLiveness.LIVE_ONLY,
+            endpoint_id: typing.Optional[builtins.str] = None,
         ) -> ConnectionStrategy.Gateway: ...
 
 @typing.final