qcs-sdk-python 0.26.0__cp313-cp313-win_amd64.whl

qcs_sdk/qpu/isa.pyi

@@ -0,0 +1,472 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import collections.abc
+import enum
+import typing
+from qcs_sdk import QcsSdkError
+from qcs_sdk.client import QCSClient
+
+@typing.final
+class Architecture:
+    r"""
+    Represents the logical underlying architecture of a quantum processor.
+    
+    The architecture is defined in detail by the nodes and edges that constitute the quantum
+    processor. This defines the set of all nodes that could be operated upon, and indicates to
+    some approximation their physical layout. The main purpose of this is to support geometry
+    calculations that are independent of the available operations, and rendering ISA-based
+    information. Architecture layouts are defined by the `family`, as follows.
+    
+    The "Aspen" family of quantum processor indicates a 2D planar grid layout of octagon unit
+    cells. The `node_id` in this architecture is computed as :math:`100 p_y + 10 p_x + p_u` where
+    :math:`p_y` is the zero-based Y position in the unit cell grid, :math:`p_x` is the zero-based
+    X position in the unit cell grid, and :math:`p_u` is the zero-based position in the octagon
+    unit cell and always ranges from 0 to 7.
+    
+    The "Ankaa" architecture is based on a grid topology; having, in "vertical" orientation,
+    qubits numbered starting from 0 at the top-left and increasing from left to right,
+    then top to bottom, so the final qubit is in the bottom-right. Each qubit is connected
+    with a tunable coupler to their direct vertical and horizontal neighbors, producing an edge.
+    Edges are ordered top-left to bottom-right in this orientation as well, with horizontal rows
+    alternating with vertical rows. Ankaa chips are, in vertical orientation,
+    7 qubits wide and 12 tall. This architecture may also be presented in "landscape"
+    orientation, which is a simple 90-degree clockwise rotation of the vertical orientation.
+    
+    Note that the operations that are actually available are defined entirely by ``Operation``
+    instances. The presence of a node or edge in the ``Architecture`` model provides no guarantee
+    that any 1Q or 2Q operation will be available to users writing QUIL programs.
+    """
+    @property
+    def edges(self) -> builtins.list[Edge]:
+        r"""
+        A list of all computational edges in the instruction set architecture.
+        """
+    @edges.setter
+    def edges(self, value: builtins.list[Edge]) -> None:
+        r"""
+        A list of all computational edges in the instruction set architecture.
+        """
+    @property
+    def family(self) -> typing.Optional[Family | builtins.str]:
+        r"""
+        The architecture family. The nodes and edges conform to this family.
+        """
+    @family.setter
+    def family(self, value: typing.Optional[Family | builtins.str]) -> None:
+        r"""
+        The architecture family. The nodes and edges conform to this family.
+        """
+    @property
+    def nodes(self) -> builtins.list[Node]:
+        r"""
+        A list of all computational nodes in the instruction set architecture.
+        """
+    @nodes.setter
+    def nodes(self, value: builtins.list[Node]) -> None:
+        r"""
+        A list of all computational nodes in the instruction set architecture.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, edges: typing.Sequence[Edge], family: typing.Optional[Family | builtins.str], nodes: typing.Sequence[Node]) -> Architecture: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+@typing.final
+class Characteristic:
+    r"""
+    A measured characteristic of an operation.
+    """
+    @property
+    def error(self) -> typing.Optional[builtins.float]:
+        r"""
+        The error in the characteristic value, or None otherwise.
+        """
+    @error.setter
+    def error(self, value: typing.Optional[builtins.float]) -> None:
+        r"""
+        The error in the characteristic value, or None otherwise.
+        """
+    @property
+    def name(self) -> builtins.str:
+        r"""
+        The name of the characteristic.
+        """
+    @name.setter
+    def name(self, value: builtins.str) -> None:
+        r"""
+        The name of the characteristic.
+        """
+    @property
+    def node_ids(self) -> typing.Optional[builtins.list[builtins.int]]:
+        r"""
+        The list of architecture node ids for the site where the characteristic is measured, if that is different from the site of the enclosing operation. None if it is the same. The order of this or the enclosing node ids obey the definition of node symmetry from the enclosing operation.
+        """
+    @node_ids.setter
+    def node_ids(self, value: typing.Optional[builtins.list[builtins.int]]) -> None:
+        r"""
+        The list of architecture node ids for the site where the characteristic is measured, if that is different from the site of the enclosing operation. None if it is the same. The order of this or the enclosing node ids obey the definition of node symmetry from the enclosing operation.
+        """
+    @property
+    def parameter_values(self) -> typing.Optional[builtins.list[builtins.float]]:
+        r"""
+        The optional ordered list of parameter values used to generate the characteristic. The order matches the parameters in the enclosing operation, and so the lengths of these two lists must match.
+        """
+    @parameter_values.setter
+    def parameter_values(self, value: typing.Optional[builtins.list[builtins.float]]) -> None:
+        r"""
+        The optional ordered list of parameter values used to generate the characteristic. The order matches the parameters in the enclosing operation, and so the lengths of these two lists must match.
+        """
+    @property
+    def timestamp(self) -> builtins.str:
+        r"""
+        The date and time at which the characteristic was measured.
+        """
+    @timestamp.setter
+    def timestamp(self, value: builtins.str) -> None:
+        r"""
+        The date and time at which the characteristic was measured.
+        """
+    @property
+    def value(self) -> builtins.float:
+        r"""
+        The characteristic value measured.
+        """
+    @value.setter
+    def value(self, value: builtins.float) -> None:
+        r"""
+        The characteristic value measured.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, name: builtins.str, timestamp: builtins.str, value: builtins.float) -> Characteristic:
+        r"""
+        A measured characteristic of an operation.
+        """
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+@typing.final
+class Edge:
+    r"""
+    A degree-two logical connection in the quantum processor's architecture.
+    
+    The existence of an edge in the ISA ``Architecture`` does not necessarily mean that a given 2Q
+    operation will be available on the edge. This information is conveyed by the presence of the
+    two `node_id` values in instances of ``Instruction``.
+    
+    Note that edges are undirected in this model. Thus edge :math:`(a, b)` is equivalent to edge
+    :math:`(b, a)`.
+    """
+    @property
+    def node_ids(self) -> builtins.list[builtins.int]:
+        r"""
+        The integer ids of the computational nodes at the two ends of the edge.
+        Order is not important; an architecture edge is treated as undirected.
+        """
+    @node_ids.setter
+    def node_ids(self, value: builtins.list[builtins.int]) -> None:
+        r"""
+        The integer ids of the computational nodes at the two ends of the edge.
+        Order is not important; an architecture edge is treated as undirected.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, node_ids: typing.Sequence[builtins.int]) -> Edge: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+class GetISAError(QcsSdkError):
+    r"""
+    Errors raised due to failure to get an ISA.
+    """
+    ...
+
+@typing.final
+class InstructionSetArchitecture:
+    r"""
+    The native instruction set architecture (ISA) of a quantum processor, annotated with characteristics.
+    
+    The operations described by the `instructions` field are named by their QUIL instruction name,
+    while the operation described by the `benchmarks` field are named by their benchmark routine
+    and are a future extension point.
+    
+    The characteristics that annotate both instructions and benchmarks assist the user to generate
+    the best native QUIL program for a desired task, and so are provided as part of the native ISA.
+    """
+    @property
+    def architecture(self) -> Architecture: ...
+    @architecture.setter
+    def architecture(self, value: Architecture) -> None: ...
+    @property
+    def benchmarks(self) -> builtins.list[Operation]:
+        r"""
+        The list of benchmarks that have characterized the quantum processor.
+        """
+    @benchmarks.setter
+    def benchmarks(self, value: builtins.list[Operation]) -> None:
+        r"""
+        The list of benchmarks that have characterized the quantum processor.
+        """
+    @property
+    def instructions(self) -> builtins.list[Operation]:
+        r"""
+        The list of native QUIL instructions supported by the quantum processor.
+        """
+    @instructions.setter
+    def instructions(self, value: builtins.list[Operation]) -> None:
+        r"""
+        The list of native QUIL instructions supported by the quantum processor.
+        """
+    @property
+    def name(self) -> builtins.str:
+        r"""
+        The name of the quantum processor.
+        """
+    @name.setter
+    def name(self, value: builtins.str) -> None:
+        r"""
+        The name of the quantum processor.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, architecture: Architecture, benchmarks: typing.Sequence[Operation], instructions: typing.Sequence[Operation], name: builtins.str) -> InstructionSetArchitecture: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+    @staticmethod
+    def from_raw(json: builtins.str) -> InstructionSetArchitecture:
+        r"""
+        Deserialize an `InstructionSetArchitecture` from a json representation.
+        
+        # Errors
+        
+        Returns [`SerializeIsaError`] if the input string was not deserialized correctly.
+        """
+    def json(self, pretty: builtins.bool = False) -> builtins.str:
+        r"""
+        Serialize the `InstructionSetArchitecture` to a json string, optionally pretty-printed.
+        
+        If `pretty` is true, the json output should be pretty-printed with newlines and indents.
+        
+        # Errors
+        
+        Returns [`SerializeIsaError`] if the ISA could not be serialized.
+        """
+
+@typing.final
+class Node:
+    r"""
+    A logical node in the quantum processor's architecture.
+    
+    The existence of a node in the ISA ``Architecture`` does not necessarily mean that a given 1Q
+    operation will be available on the node. This information is conveyed by the presence of the
+    specific `node_id` in instances of ``Instruction``.
+    """
+    @property
+    def node_id(self) -> builtins.int:
+        r"""
+        An integer id assigned to the computational node.
+        
+        The ids may not be contiguous and will be assigned based on the architecture family.
+        """
+    @node_id.setter
+    def node_id(self, value: builtins.int) -> None:
+        r"""
+        An integer id assigned to the computational node.
+        
+        The ids may not be contiguous and will be assigned based on the architecture family.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, node_id: builtins.int) -> Node: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+@typing.final
+class Operation:
+    r"""
+    An operation, with its sites and site-independent characteristics.
+    """
+    @property
+    def characteristics(self) -> builtins.list[Characteristic]:
+        r"""
+        The list of site-independent characteristics of this operation.
+        """
+    @characteristics.setter
+    def characteristics(self, value: builtins.list[Characteristic]) -> None:
+        r"""
+        The list of site-independent characteristics of this operation.
+        """
+    @property
+    def name(self) -> builtins.str:
+        r"""
+        The name of the operation.
+        """
+    @name.setter
+    def name(self, value: builtins.str) -> None:
+        r"""
+        The name of the operation.
+        """
+    @property
+    def node_count(self) -> typing.Optional[builtins.int]:
+        r"""
+        The number of nodes that this operation applies to. None if unspecified.
+        """
+    @node_count.setter
+    def node_count(self, value: typing.Optional[builtins.int]) -> None:
+        r"""
+        The number of nodes that this operation applies to. None if unspecified.
+        """
+    @property
+    def parameters(self) -> builtins.list[Parameter]:
+        r"""
+        The list of parameters. Each parameter must be uniquely named. May be empty.
+        """
+    @parameters.setter
+    def parameters(self, value: builtins.list[Parameter]) -> None:
+        r"""
+        The list of parameters. Each parameter must be uniquely named. May be empty.
+        """
+    @property
+    def sites(self) -> builtins.list[OperationSite]:
+        r"""
+        The list of sites at which this operation can be applied, together with its site-dependent characteristics.
+        """
+    @sites.setter
+    def sites(self, value: builtins.list[OperationSite]) -> None:
+        r"""
+        The list of sites at which this operation can be applied, together with its site-dependent characteristics.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, characteristics: typing.Sequence[Characteristic], name: builtins.str, parameters: typing.Sequence[Parameter], sites: typing.Sequence[OperationSite]) -> Operation:
+        r"""
+        An operation, with its sites and site-independent characteristics.
+        """
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+@typing.final
+class OperationSite:
+    r"""
+    A site for an operation, with its site-dependent characteristics.
+    """
+    @property
+    def characteristics(self) -> builtins.list[Characteristic]:
+        r"""
+        The list of site-dependent characteristics of this operation.
+        """
+    @characteristics.setter
+    def characteristics(self, value: builtins.list[Characteristic]) -> None:
+        r"""
+        The list of site-dependent characteristics of this operation.
+        """
+    @property
+    def node_ids(self) -> builtins.list[builtins.int]:
+        r"""
+        The list of architecture node ids for the site.
+        
+        The order of these node ids obey the definition of node symmetry from the enclosing operation.
+        """
+    @node_ids.setter
+    def node_ids(self, value: builtins.list[builtins.int]) -> None:
+        r"""
+        The list of architecture node ids for the site.
+        
+        The order of these node ids obey the definition of node symmetry from the enclosing operation.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, characteristics: typing.Sequence[Characteristic], node_ids: typing.Sequence[builtins.int]) -> OperationSite:
+        r"""
+        A site for an operation, with its site-dependent characteristics.
+        """
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+@typing.final
+class Parameter:
+    r"""
+    A parameter to an operation.
+    """
+    @property
+    def name(self) -> builtins.str:
+        r"""
+        The name of the parameter, such as the name of a mathematical symbol.
+        """
+    @name.setter
+    def name(self, value: builtins.str) -> None:
+        r"""
+        The name of the parameter, such as the name of a mathematical symbol.
+        """
+    def __eq__(self, other: builtins.object) -> builtins.bool: ...
+    def __new__(cls, name: builtins.str) -> Parameter: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+class SerializeISAError(QcsSdkError):
+    r"""
+    Errors raised due to failure to serialize an ISA.
+    """
+    ...
+
+@typing.final
+class Family(enum.Enum):
+    r"""
+    The architecture family identifier of an ``InstructionSetArchitecture``.
+    
+    Value 'NONE' implies the architecture has no specific layout topology.
+    Value 'FULL' implies that each node is connected to every other (a fully-connected architecture).
+    For other values based on deployed architecture layouts (e.g. `Aspen` and `Ankaa`),
+    refer to the architecture classes themselves for more details.
+    
+    Note: Within an ``InstructionSetArchitecture``, the `family` may be one of these,
+    or may be a `str` for an unknown family, or may be `None` if the `family` is not specified.
+    The latter in particular is distinct from the `NONE` value within this enumeration.
+    """
+    NONE = ...
+    FULL = ...
+    ASPEN = ...
+    ANKAA = ...
+
+def get_instruction_set_architecture(quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None) -> InstructionSetArchitecture:
+    r"""
+    Fetch the ``InstructionSetArchitecture`` (ISA) for a given `quantum_processor_id` from the QCS API.
+    
+    :param quantum_processor_id: The ID of the quantum processor.
+    :param client: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    
+    :raises LoadClientError: If ``client`` was not provided to the function, and failed to load internally.
+    :raises GetISAError: If there was an issue fetching the ISA from the QCS API.
+    """
+
+def get_instruction_set_architecture_async(quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None) -> collections.abc.Awaitable[InstructionSetArchitecture]:
+    r"""
+    Fetch the ``InstructionSetArchitecture`` (ISA) for a given `quantum_processor_id` from the QCS API.
+    
+    :param quantum_processor_id: The ID of the quantum processor.
+    :param client: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    
+    :raises LoadClientError: If ``client`` was not provided to the function, and failed to load internally.
+    :raises GetISAError: If there was an issue fetching the ISA from the QCS API.
+    """
+

qcs_sdk/qpu/translation.pyi

@@ -0,0 +1,180 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import collections.abc
+import enum
+import typing
+from qcs_sdk import QcsSdkError
+from qcs_sdk.client import QCSClient
+
+@typing.final
+class QCtrl:
+    r"""
+    Options for compiling programs through the Q-CTRL API.
+    
+    Options here are specially authorized and are not generally available to the client.
+    """
+    def __new__(cls, fixed_layout: typing.Optional[builtins.bool] = None) -> QCtrl: ...
+
+@typing.final
+class Riverlane:
+    r"""
+    Options for configuring Riverlane features prior to execution.
+    
+    Options here are specially authorized and are not generally available to the client.
+    """
+    def __new__(cls, qeci_configuration_data: typing.Mapping[builtins.str, typing.Sequence[builtins.int]], qeci_max_nanoseconds_until_read_available: builtins.int) -> Riverlane: ...
+
+class TranslationError(QcsSdkError):
+    r"""
+    Errors raised due to failure to translate a program.
+    """
+    ...
+
+@typing.final
+class TranslationOptions:
+    r"""
+    Options available for Quil program translation.
+    
+    This wraps [`ApiTranslationOptions`] in order to improve the user experience,
+    because the structs auto-generated by `prost` can be clumsy to use directly.
+    """
+    @property
+    def backend(self) -> typing.Optional[TranslationBackend]:
+        r"""
+        Get the backend used for translation
+        """
+    def __new__(cls) -> TranslationOptions: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+    def encode_as_protobuf(self) -> bytes:
+        r"""
+        Serialize these translation options into the Protocol Buffer format.
+        """
+    def use_backend_v1(self) -> None:
+        r"""
+        Use the first-generation translation backend available on QCS since 2018.
+        """
+    def use_backend_v2(self) -> None:
+        r"""
+        Use the second-generation translation backend available on QCS since 2023.
+        """
+    def use_q_ctrl(self, q_ctrl: typing.Optional[QCtrl] = None) -> None:
+        r"""
+        Compile the program through Q-CTRL's API prior to translation.
+        
+        The client should generally leave the `q_ctrl` compile options unset
+        as it is specially authorized and not generally available.
+        """
+    def use_riverlane(self, riverlane: Riverlane = ...) -> None:
+        r"""
+        Configure Riverlane features prior to execution.
+        
+        Options here are specially authorized and are not generally available to the client.
+        """
+    @staticmethod
+    def v1() -> TranslationOptions:
+        r"""
+        Use the v1 backend for translation, available on QCS since 2018.
+        """
+    @staticmethod
+    def v2(*, prepend_default_calibrations: typing.Optional[builtins.bool] = None, passive_reset_delay_seconds: typing.Optional[builtins.float] = None, allow_unchecked_pointer_arithmetic: typing.Optional[builtins.bool] = None, allow_frame_redefinition: typing.Optional[builtins.bool] = None) -> TranslationOptions:
+        r"""
+        Use the v2 backend for translation, available on QCS since 2023.
+        
+        :param `prepend_default_calibrations`: If False, do not prepend the default calibrations to the translated program.
+        :param `passive_reset_delay_seconds`: The delay between passive resets, in seconds.
+        :param `allow_unchecked_pointer_arithmetic`: If True, disable runtime memory bounds checking. Only available to certain users.
+        :param `allow_frame_redefinition`: If True, allow defined frames to differ from Rigetti defaults. Only available to certain users. Otherwise, only ``INITIAL-FREQUENCY`` and ``CHANNEL-DELAY`` may be modified.
+        """
+
+@typing.final
+class TranslationResult:
+    r"""
+    The result of a call to [`translate`] which provides information about the translated program.
+    """
+    @property
+    def program(self) -> builtins.str:
+        r"""
+        The translated program.
+        """
+    @property
+    def ro_sources(self) -> typing.Optional[builtins.dict[builtins.str, builtins.str]]:
+        r"""
+        A mapping from the program's memory references to the key used to index the results map.
+        """
+
+@typing.final
+class TranslationBackend(enum.Enum):
+    r"""
+    The backend used for translation.
+    """
+    V1 = ...
+    r"""
+    The first-generation translation backend available on QCS since 2018.
+    """
+    V2 = ...
+    r"""
+    The second-generation translation backend available on QCS since 2023.
+    """
+
+def get_quilt_calibrations(quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None, timeout: typing.Optional[builtins.float] = None) -> builtins.str:
+    r"""
+    Retrieve the calibration data used for client-side Quil-T generation.
+    
+    :param `quantum_processor_id`: The ID of the quantum processor.
+    :param `client`: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    :param `timeout`: Maximum duration to wait for API calls to complete, in seconds. Defaults to 10 seconds.
+    
+    :returns: The Quil calibration program for the requested quantum processor.
+    
+    :raises `LoadClientError`: If there is an issue loading the QCS Client configuration.
+    :raises `TranslationError`: If there was a problem fetching Quil-T calibrations.
+    """
+
+def get_quilt_calibrations_async(quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None, timeout: typing.Optional[builtins.float] = None) -> collections.abc.Awaitable[builtins.str]:
+    r"""
+    Retrieve the calibration data used for client-side Quil-T generation.
+    
+    :param `quantum_processor_id`: The ID of the quantum processor.
+    :param `client`: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    :param `timeout`: Maximum duration to wait for API calls to complete, in seconds. Defaults to 10 seconds.
+    
+    :returns: The Quil calibration program for the requested quantum processor.
+    
+    :raises `LoadClientError`: If there is an issue loading the QCS Client configuration.
+    :raises `TranslationError`: If there was a problem fetching Quil-T calibrations.
+    """
+
+def translate(native_quil: builtins.str, num_shots: builtins.int, quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None, translation_options: typing.Optional[TranslationOptions] = None) -> TranslationResult:
+    r"""
+    Translates a native Quil program into an executable program.
+    
+    :param `native_quil`: A Quil program.
+    :param `num_shots`: The number of shots to perform.
+    :param `quantum_processor_id`: The ID of the quantum processor the executable will run on (e.g. "Aspen-M-2").
+    :param `client`: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    :param `translation_options`: Optional translation options.
+    
+    :raises `LoadClientError`: If there is an issue loading the QCS Client configuration.
+    :raises `TranslationError`: If the `native_quil` program could not be translated.
+    """
+
+def translate_async(native_quil: builtins.str, num_shots: builtins.int, quantum_processor_id: builtins.str, client: typing.Optional[QCSClient] = None, translation_options: typing.Optional[TranslationOptions] = None) -> collections.abc.Awaitable[TranslationResult]:
+    r"""
+    Translates a native Quil program into an executable program.
+    
+    :param `native_quil`: A Quil program.
+    :param `num_shots`: The number of shots to perform.
+    :param `quantum_processor_id`: The ID of the quantum processor the executable will run on (e.g. "Aspen-M-2").
+    :param `client`: The ``Qcs`` client to use. Creates one using environment configuration if unset - see https://docs.rigetti.com/qcs/references/qcs-client-configuration
+    :param `translation_options`: Optional translation options.
+    
+    :raises `LoadClientError`: If there is an issue loading the QCS Client configuration.
+    :raises `TranslationError`: If the `native_quil` program could not be translated.
+    """
+