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

qcs_sdk/qvm/__init__.pyi

@@ -0,0 +1,162 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import collections.abc
+import typing
+from qcs_sdk import QcsSdkError, RegisterData, RegisterMap
+from qcs_sdk.qvm.api import AddressRequest
+from . import api
+
+@typing.final
+class QVMClient:
+    r"""
+    Client used to communicate with QVM.
+    """
+    @property
+    def qvm_url(self) -> builtins.str:
+        r"""
+        Return the address of the client.
+        """
+    def __new__(cls) -> QVMClient: ...
+    @staticmethod
+    def new_http(endpoint: builtins.str) -> QVMClient:
+        r"""
+        Construct a new QVM client which uses HTTP to communicate with a QVM service.
+        """
+    @staticmethod
+    def new_libquil() -> QVMClient: ...
+
+class QVMError(QcsSdkError):
+    r"""
+    Errors that can occur when running a Quil program on QVM.
+    """
+    ...
+
+@typing.final
+class QVMOptions:
+    r"""
+    Options avaialable for running programs on the QVM.
+    """
+    @property
+    def timeout(self) -> typing.Optional[builtins.float]:
+        r"""
+        The timeout used for requests to the QVM. If set to None, there is no timeout.
+        """
+    @timeout.setter
+    def timeout(self, value: typing.Optional[builtins.float]) -> None:
+        r"""
+        The timeout used for requests to the QVM. If set to None, there is no timeout.
+        """
+    def __new__(cls, timeout_seconds: typing.Optional[builtins.float] = None) -> QVMOptions: ...
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+    @staticmethod
+    def default() -> QVMOptions:
+        r"""
+        Get the default set of ``QVMOptions`` used for QVM requests.
+        
+        Settings:
+            timeout: 30.0 seconds
+        """
+
+@typing.final
+class QVMResultData:
+    r"""
+    Encapsulates data returned after running a program on the QVM
+    """
+    @property
+    def memory(self) -> builtins.dict[builtins.str, RegisterData]:
+        r"""
+        A map of register names (ie. "ro") to a `RegisterData` containing their values.
+        """
+    def __getnewargs__(self) -> tuple[builtins.dict[builtins.str, RegisterData]]: ...
+    def __new__(cls, memory: typing.Mapping[builtins.str, RegisterData]) -> QVMResultData:
+        r"""
+        Build a ``QVMResultData`` from a mapping of register names to a ``RegisterData`` matrix.
+        """
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+    @staticmethod
+    def from_memory_map(memory: typing.Mapping[builtins.str, RegisterData]) -> QVMResultData:
+        r"""
+        Build a [`QvmResultData`] from a mapping of register names to a [`RegisterData`]
+        """
+    def to_raw_readout_data(self) -> RawQVMReadoutData:
+        r"""
+        Get a copy of this result data flattened into a ``RawQVMReadoutData``.
+        """
+    def to_register_map(self) -> RegisterMap:
+        r"""
+        Convert into a [`RegisterMap`].
+        
+        The [`RegisterMatrix`] for each register will be
+        constructed such that each row contains all the final values in the register for a single shot.
+        
+        # Errors
+        
+        Returns a [`RegisterMatrixConversionError`] if the inner execution data for any of the
+        registers would result in a jagged matrix.
+        This is often the case in programs that use mid-circuit measurement or dynamic control flow,
+        where measurements to the same memory reference might occur multiple times in a shot, or be
+        skipped conditionally. In these cases, building a rectangular [`RegisterMatrix`] would
+        necessitate making assumptions about the data that could skew the data in undesirable ways.
+        Instead, it's recommended to manually build a matrix from [`QpuResultData`] that accurately
+        selects the last value per-shot based on the program that was run.
+        """
+
+@typing.final
+class RawQVMReadoutData:
+    r"""
+    Encapsulates raw data returned from the QVM after executing a program.
+    """
+    @property
+    def memory(self) -> builtins.dict[builtins.str, list]:
+        r"""
+        The mapping of register names (ie. "ro") to a 2-d list containing the
+        values for that register.
+        """
+    def __repr__(self) -> builtins.str:
+        r"""
+        Implements `__repr__` for Python in terms of the Rust
+        [`Debug`](std::fmt::Debug) implementation.
+        """
+
+def run(quil: builtins.str, shots: builtins.int, addresses: typing.Mapping[builtins.str, AddressRequest], params: typing.Mapping[builtins.str, typing.Sequence[builtins.float]], client: QVMClient, measurement_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, gate_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, rng_seed: typing.Optional[builtins.int] = None, options: typing.Optional[QVMOptions] = None) -> QVMResultData:
+    r"""
+    Runs the given program on the QVM.
+    
+    :param quil: A quil program as a string.
+    :param shots: The number of times to run the program. Should be a value greater than zero.
+    :param addresses: A mapping of memory region names to an ``AddressRequest`` describing what data to get back for that memory region from the QVM at the end of execution.
+    :param params: A mapping of memory region names to their desired values.
+    :param client: An optional ``QCSClient`` to use. If unset, creates one using the environemnt configuration (see https://docs.rigetti.com/qcs/references/qcs-client-configuration).
+    :param options: An optional ``QVMOptions`` to use. If unset, uses ``QVMOptions.default()`` for the request.
+    
+    :returns: A ``QVMResultData`` containing the final state of of memory for the requested readouts after the program finished running.
+    
+    :raises QVMError: If one of the parameters is invalid, or if there was a problem communicating with the QVM server.
+    """
+
+def run_async(quil: builtins.str, shots: builtins.int, addresses: typing.Mapping[builtins.str, AddressRequest], params: typing.Mapping[builtins.str, typing.Sequence[builtins.float]], client: QVMClient, measurement_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, gate_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, rng_seed: typing.Optional[builtins.int] = None, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[QVMResultData]:
+    r"""
+    Runs the given program on the QVM.
+    
+    :param quil: A quil program as a string.
+    :param shots: The number of times to run the program. Should be a value greater than zero.
+    :param addresses: A mapping of memory region names to an ``AddressRequest`` describing what data to get back for that memory region from the QVM at the end of execution.
+    :param params: A mapping of memory region names to their desired values.
+    :param client: An optional ``QCSClient`` to use. If unset, creates one using the environemnt configuration (see https://docs.rigetti.com/qcs/references/qcs-client-configuration).
+    :param options: An optional ``QVMOptions`` to use. If unset, uses ``QVMOptions.default()`` for the request.
+    
+    :returns: A ``QVMResultData`` containing the final state of of memory for the requested readouts after the program finished running.
+    
+    :raises QVMError: If one of the parameters is invalid, or if there was a problem communicating with the QVM server.
+    """
+

qcs_sdk/qvm/api.pyi

@@ -0,0 +1,236 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import builtins
+import collections.abc
+import typing
+from qcs_sdk import RegisterData
+from qcs_sdk.qvm import QVMClient, QVMOptions
+
+class AddressRequest:
+    r"""
+    An enum encapsulating the different ways to request data back from the QVM for an address.
+    """
+    @typing.final
+    class ExcludeAll(AddressRequest):
+        r"""
+        Exclude all values for the address.
+        """
+        __match_args__ = ()
+        def __getitem__(self, key: builtins.int) -> typing.Any: ...
+        def __len__(self) -> builtins.int: ...
+        def __new__(cls) -> AddressRequest.ExcludeAll: ...
+    
+    @typing.final
+    class IncludeAll(AddressRequest):
+        r"""
+        Get all values for the address.
+        """
+        __match_args__ = ()
+        def __getitem__(self, key: builtins.int) -> typing.Any: ...
+        def __len__(self) -> builtins.int: ...
+        def __new__(cls) -> AddressRequest.IncludeAll: ...
+    
+    @typing.final
+    class Indices(AddressRequest):
+        r"""
+        A list of specific indices to get back for the address.
+        """
+        __match_args__ = ("_0",)
+        @property
+        def _0(self) -> builtins.list[builtins.int]: ...
+        def __getitem__(self, key: builtins.int) -> typing.Any: ...
+        def __len__(self) -> builtins.int: ...
+        def __new__(cls, _0: typing.Sequence[builtins.int]) -> AddressRequest.Indices: ...
+    
+    ...
+
+@typing.final
+class ExpectationRequest:
+    r"""
+    The request body needed for a [`measure_expectation`] request to the QVM.
+    """
+    @property
+    def operators(self) -> builtins.list[builtins.str]:
+        r"""
+        A list of Pauli operators to measure.
+        """
+    @property
+    def rng_seed(self) -> typing.Optional[builtins.int]:
+        r"""
+        An optional seed for the random number generator.
+        """
+    @property
+    def state_preparation(self) -> builtins.str:
+        r"""
+        A Quil program defining the state.
+        """
+    def __new__(cls, state_preparation: builtins.str, operators: typing.Sequence[builtins.str], rng_seed: typing.Optional[builtins.int] = None) -> ExpectationRequest:
+        r"""
+        Creates a new `ExpectationRequest` using the given parameters.
+        """
+
+@typing.final
+class MultishotMeasureRequest:
+    r"""
+    The request body needed for a [`run_and_measure`] request to the QVM.
+    """
+    @property
+    def compiled_quil(self) -> builtins.str:
+        r"""
+        The Quil program to run.
+        """
+    @property
+    def gate_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated gate noise for the X, Y, and Z axes.
+        """
+    @property
+    def measurement_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated measurement noise for the X, Y, and Z axes.
+        """
+    @property
+    def qubits(self) -> builtins.list[builtins.int]:
+        r"""
+        Qubits to measure
+        """
+    @property
+    def rng_seed(self) -> typing.Optional[builtins.int]:
+        r"""
+        An optional seed for the random number generator.
+        """
+    @property
+    def trials(self) -> builtins.int: ...
+    @trials.setter
+    def trials(self, value: builtins.int) -> None: ...
+    def __new__(cls, compiled_quil: builtins.str, trials: builtins.int, qubits: builtins.list[builtins.int], measurement_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, gate_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, rng_seed: typing.Optional[builtins.int] = None) -> MultishotMeasureRequest:
+        r"""
+        Construct a new `MultishotMeasureRequest` using the given parameters.
+        """
+
+@typing.final
+class MultishotRequest:
+    r"""
+    The request body needed to make a multishot [`run`] request to the QVM.
+    """
+    @property
+    def addresses(self) -> builtins.dict[builtins.str, AddressRequest]:
+        r"""
+        The memory regions to include in the response.
+        """
+    @addresses.setter
+    def addresses(self, value: builtins.dict[builtins.str, AddressRequest]) -> None:
+        r"""
+        The memory regions to include in the response.
+        """
+    @property
+    def compiled_quil(self) -> builtins.str:
+        r"""
+        The Quil program to run.
+        """
+    @compiled_quil.setter
+    def compiled_quil(self, value: builtins.str) -> None:
+        r"""
+        The Quil program to run.
+        """
+    @property
+    def gate_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated gate noise for the X, Y, and Z axes.
+        """
+    @gate_noise.setter
+    def gate_noise(self, value: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]) -> None:
+        r"""
+        Simulated gate noise for the X, Y, and Z axes.
+        """
+    @property
+    def measurement_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated measurement noise for the X, Y, and Z axes.
+        """
+    @measurement_noise.setter
+    def measurement_noise(self, value: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]) -> None:
+        r"""
+        Simulated measurement noise for the X, Y, and Z axes.
+        """
+    @property
+    def rng_seed(self) -> typing.Optional[builtins.int]:
+        r"""
+        An optional seed for the random number generator.
+        """
+    @rng_seed.setter
+    def rng_seed(self, value: typing.Optional[builtins.int]) -> None:
+        r"""
+        An optional seed for the random number generator.
+        """
+    @property
+    def trials(self) -> builtins.int: ...
+    @trials.setter
+    def trials(self, value: builtins.int) -> None: ...
+    def __new__(cls, program: builtins.str, shots: builtins.int, addresses: typing.Mapping[builtins.str, AddressRequest], measurement_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, gate_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, rng_seed: typing.Optional[builtins.int] = None) -> MultishotRequest:
+        r"""
+        Creates a new `MultishotRequest` with the given parameters.
+        """
+
+@typing.final
+class MultishotResponse:
+    r"""
+    The response body returned by the QVM after a multishot [`run`] request.
+    """
+    @property
+    def registers(self) -> builtins.dict[builtins.str, RegisterData]:
+        r"""
+        The requested readout registers and their final values for each shot.
+        """
+
+@typing.final
+class WavefunctionRequest:
+    r"""
+    The request body needed to make a [`get_wavefunction`] request to the QVM.
+    """
+    @property
+    def compiled_quil(self) -> builtins.str:
+        r"""
+        The Quil program to run.
+        """
+    @property
+    def gate_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated gate noise for the X, Y, and Z axes.
+        """
+    @property
+    def measurement_noise(self) -> typing.Optional[tuple[builtins.float, builtins.float, builtins.float]]:
+        r"""
+        Simulated measurement noise for the X, Y, and Z axes.
+        """
+    @property
+    def rng_seed(self) -> typing.Optional[builtins.int]:
+        r"""
+        An optional seed for the random number generator.
+        """
+    def __new__(cls, compiled_quil: builtins.str, measurement_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, gate_noise: typing.Optional[tuple[builtins.float, builtins.float, builtins.float]] = None, rng_seed: typing.Optional[builtins.int] = None) -> WavefunctionRequest:
+        r"""
+        Create a new `WavefunctionRequest` with the given parameters.
+        """
+
+def get_version_info(client: QVMClient, options: typing.Optional[QVMOptions] = None) -> builtins.str: ...
+
+def get_version_info_async(client: QVMClient, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[builtins.str]: ...
+
+def get_wavefunction(request: WavefunctionRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> builtins.list[builtins.int]: ...
+
+def get_wavefunction_async(request: WavefunctionRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[builtins.list[builtins.int]]: ...
+
+def measure_expectation(request: ExpectationRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> builtins.list[builtins.float]: ...
+
+def measure_expectation_async(request: ExpectationRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[builtins.list[builtins.float]]: ...
+
+def run(request: MultishotRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> MultishotResponse: ...
+
+def run_and_measure(request: MultishotMeasureRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> builtins.list[builtins.list[builtins.int]]: ...
+
+def run_and_measure_async(request: MultishotMeasureRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[builtins.list[builtins.list[builtins.int]]]: ...
+
+def run_async(request: MultishotRequest, client: QVMClient, options: typing.Optional[QVMOptions] = None) -> collections.abc.Awaitable[MultishotResponse]: ...
+

qcs_sdk_python-0.26.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: qcs-sdk-python
+Version: 0.26.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+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.35.0,<0.36.0
+Requires-Dist: qcs-api-client-common>=0.15.0,<0.16.0
+Summary: Python interface for the QCS Rust SDK
+Author-email: Rigetti Computing <softapps@rigetti.com>, Mark Skilbeck <mark.skilbeck@rigetti.com>, Marquess Valdez <mvaldez@rigetti.com>, Randall Fulton <rfulton@rigetti.com>
+License: Apache-2.0
+Requires-Python: >=3.10, <4
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# QCS SDK Python
+
+⚠️ In Development
+
+`qcs-sdk-python` provides an interface to Rigetti [Quantum Cloud Services](https://docs.rigetti.com/qcs/) (QCS), allowing users
+to compile and run Quil programs on Rigetti quantum processors. Internally, it is powered by the [QCS Rust SDK](https://github.com/rigetti/qcs-sdk-rust).
+
+While this package can be used directly, [pyQuil](https://pypi.org/project/pyquil/) offers more functionality and a 
+higher-level interface for building and executing Quil programs. This package is still in early development and breaking changes should be expected between minor versions.
+
+# Documentation
+
+Documentation for the current release of `qcs_sdk` is published [here](https://rigetti.github.io/qcs-sdk-rust/qcs_sdk.html). Every version of `qcs_sdk` ships [with type stubs](https://github.com/rigetti/qcs-sdk-rust/tree/main/crates/lib/python/qcs_sdk) that can provide type hints and documentation to Python tooling and editors.
+
+## Troubleshooting
+
+### Enabling Debug logging
+
+This package integrates with Python's [logging facility](https://docs.python.org/3/library/logging.html) through a Rust crate called [`pyo3_log`](https://docs.rs/pyo3-log/latest/pyo3_log/). The quickest way to get started is to just enable debug logging:
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+Because this is implemented with Rust, there are some important differences in regards to log levels and filtering.
+
+#### The `TRACE` log level
+
+Rust has a `TRACE` log level that doesn't exist in Python. It is less severe than `DEBUG` and is set to a value of 5. While the `DEBUG` level is recommended for troubleshooting, you can choose to target `TRACE` level logs and below like so:
+
+```python
+import logging
+logging.basicConfig(level=5)
+```
+
+#### Runtime Configuration and Caching
+ 
+`pyo3_log` caches loggers and their level filters to improve performance. This means that logger re-configuration done at runtime may cause unexpected logging behavior in certain situations. If this is a concern, [this section of the pyo3_log documentation](https://docs.rs/pyo3-log/latest/pyo3_log/#performance-filtering-and-caching) goes into more detail.
+
+These caches can be reset using the following:
+
+```python
+qcs_sdk.reset_logging()
+```
+
+This will allow the logging handlers to pick up the most recently-applied configuration from the Python side.
+
+#### Filtering Logs
+
+Because the logs are emitted from a Rust library, the logger names will correspond to the fully qualified path of the Rust module in the library where the log occurred. These fully qualified paths all have their own logger, and have to be configured individually.
+
+For example, say you wanted to disable the following log:
+
+```
+DEBUG:hyper.proto.h1.io:flushed 124 bytes
+```
+
+You could get the logger for `hyper.proto.h1.io` and disable it like so:
+
+```python
+logging.getLogger("hyper.proto.h1.io").disabled = True
+```
+
+This can become cumbersome, since there are a handful of libraries all logging from a handful of modules that you may not be concerned with. A less cumbersome, but more heavy handed approach is to apply a filter to all logging handlers at runtime. For example, if you only cared about logs from a `qcs` library, you could setup a log filter like so:
+
+```python
+class QCSLogFilter(logging.Filter):
+    def filter(self, record) -> bool:
+        return "qcs" in record.name
+
+for handler in logging.root.handlers:
+    handler.addFilter(QCSLogFilter())
+```
+
+This applies to all logs, so you may want to tune the `filter` method to include other logs you care about. See the caching section above for important information about the application of these filters.
+
+#### OpenTelemetry Integration
+
+This package supports collection of [OpenTelemetry trace data](https://opentelemetry.io/docs/concepts/signals/traces/). Clients may configure any OpenTelemetry [collector](https://opentelemetry.io/docs/collector/) that supports the [OTLP Specification](https://opentelemetry.io/docs/specs/otlp/). _Rigetti will not have access to the OpenTelemetry data you collect_.
+
+To enable the integration, you should install the `qcs-sdk[tracing-opentelemetry]` extra; this installs [opentelemetry-api](https://pypi.org/project/opentelemetry-api/). By default, no tracing data is collected at runtime. Because the QCS-SDK is built as a pyo3 Rust extension-module, you will need to use [pyo3-tracing-subscriber](https://crates.io/crates/pyo3-tracing-subscriber) to configure collection of your client network requests. See `qcs_sdk._tracing_subscriber` module level documentation for more detail.
+
+```python
+import my_module
+from qcs_sdk._tracing_subscriber import (
+    GlobalTracingConfig,
+    SimpleConfig,
+    Tracing,
+    subscriber,
+)
+from qcs_sdk._tracing_subscriber.layers import otel_otlp
+
+
+def main():
+    tracing_configuration = GlobalTracingConfig(
+        export_process=SimpleConfig(
+            subscriber=subscriber.Config(
+                # By default this supports the standard OTLP environment variables.
+                # See https://opentelemetry.io/docs/specs/otel/protocol/exporter/
+                layer=otel_otlp.Config()
+            )
+        )
+    )
+    with Tracing(config=config):
+        result = my_module.example_function()
+        my_module.other_example_function(result)
+
+if __name__ == '__main__':
+    main()
+```
+

qcs_sdk_python-0.26.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+README-py.md,sha256=wkf42RAgilHm1Ey9iOQfhud8r-o3fx71J7m1IaK0hPc,5458
+THIRDPARTY.yaml,sha256=_E47ATBDhoCUSeXFv8Lu6lnC0iKe_PpbQdcm8EJcuW0,3843414
+qcs_sdk/__init__.py,sha256=h9n3keETqxXFnYOE1eTXYigAxGffw17sSHd1IG3C3lE,851
+qcs_sdk/__init__.pyi,sha256=Ps00JgVcKF4oh2ZMJSuOyIWC30NaJfbf7aLU7PIttOI,18833
+qcs_sdk/_qcs_sdk.cp313-win_amd64.pyd,sha256=wXUx2DzzOxSb1-6UgCVCCRfUcncXP3wMhoYaw-Io_88,23383040
+qcs_sdk/_tracing_subscriber/.stubtest-allowlist,sha256=u1H1N-VH0rrwrhrqGdmb0mtL8gKYhZ9lHx6CN3y4TVI,346
+qcs_sdk/_tracing_subscriber/__init__.py,sha256=qDCV2SV3SEMMM7aJLX12GTmEIQPFowJ8DqxxFcaATXw,1032
+qcs_sdk/_tracing_subscriber/__init__.pyi,sha256=5NUfBcwUJ4JcyY-mV93nw8OmyQHAkIUzO96EG-9XD2o,4838
+qcs_sdk/_tracing_subscriber/common/__init__.py,sha256=UAgEm6x_ZNUNYm7Ws9h6ptMr0-vEfj0UoIUcVNGdmpc,1015
+qcs_sdk/_tracing_subscriber/common/__init__.pyi,sha256=tNhe97M8D22FbXkmNVVU4Uk9qq-M0X6xTgMUvnG3b44,2131
+qcs_sdk/_tracing_subscriber/layers/__init__.py,sha256=prNQQVxVhn23sHFDcz-iXdmH_Rrrsr3_deKIlJWkk24,1015
+qcs_sdk/_tracing_subscriber/layers/__init__.pyi,sha256=fpFEDhfEd5bQk9BMo49VPYFLVH1g3oyV_wsT50lzC-0,1335
+qcs_sdk/_tracing_subscriber/layers/file/__init__.py,sha256=jXgr55kJPcP33DOtVxRs6kmfj1dNfhwh-4DAO_56qzU,1018
+qcs_sdk/_tracing_subscriber/layers/file/__init__.pyi,sha256=cD_wXxnweQWPX2Xc8qtwRN2KpC8hPmsgaZdcIFcgLGM,2305
+qcs_sdk/_tracing_subscriber/layers/otel_otlp/__init__.py,sha256=Ci1PFxlP8NP_b_dXgD8HiTiLyDs6lGb0w2LG_I6gqjg,1031
+qcs_sdk/_tracing_subscriber/layers/otel_otlp/__init__.pyi,sha256=GdQfO80uKejXd8o751QrRycnAVI_ycGw1O_qBrF9f3Y,6012
+qcs_sdk/_tracing_subscriber/layers/otel_otlp_file/__init__.py,sha256=JoC0W1pZ_ldkrkVpW8NWtfrDboNW3970s_nBEetWrF0,1046
+qcs_sdk/_tracing_subscriber/layers/otel_otlp_file/__init__.pyi,sha256=n-QJEqqrAQgI1CP2W_ANqHQ_WqubFIoXmxz5g6sPXLg,2259
+qcs_sdk/_tracing_subscriber/subscriber/__init__.py,sha256=DEY-03lRFC25KKQ__vnN85Zvv1F7cujOTj5wSGEDpgU,1027
+qcs_sdk/_tracing_subscriber/subscriber/__init__.pyi,sha256=HrW9wG_ycjBxQsD9JSveAC9kgxsRExFPCXQbzHJN-8s,1212
+qcs_sdk/client.pyi,sha256=Vq9BoveELJYJZ_ULzasdFnnU2OVn1yg9uvswukCHMeI,4942
+qcs_sdk/compiler/__init__.pyi,sha256=acfuDXFdFkWtoAHX79dV6YywowN-xrxvfc6h-JQ4VfQ,108
+qcs_sdk/compiler/quilc.pyi,sha256=Of1fy1lc7rTF0hoZwAvvwCkM1aFH3URErTDj9WEnNkI,11899
+qcs_sdk/diagnostics.pyi,sha256=f1BCiAfeKoUOrvYGG7wTHd97nwwH9V9Rj1SnLONw06g,1024
+qcs_sdk/qpu/__init__.pyi,sha256=zgKsMrFVdDi12E-o2ljGCZ5qKgrvDedjvL5xUPyh1oQ,9627
+qcs_sdk/qpu/api.pyi,sha256=YpmoY3lvUVVx8kRLCVu-qe_1ivmaPrsuzGQsLWFuqjc,24566
+qcs_sdk/qpu/experimental/__init__.pyi,sha256=FZ34r9egG_is2rQB9swAu1zELyolZtbKmILajDrCVuU,109
+qcs_sdk/qpu/experimental/random.pyi,sha256=peEo0ZXfKtO1hZMija0ohnDsPlmJUZYwnHl0qAZHhpI,3768
+qcs_sdk/qpu/isa.pyi,sha256=y3pZl_djB2WO0cszZ_E8QTkPqhTTsW9gKgoAzbsTGy8,19920
+qcs_sdk/qpu/translation.pyi,sha256=65Ry--0CE59i3SMOPvee52ga3JZx1b_WsKpkPNXAO1A,8549
+qcs_sdk/qvm/__init__.pyi,sha256=QNLF22nr04K4rkcKHkHsIIKOJQv6EETm_O4yxmF8-Aw,7784
+qcs_sdk/qvm/api.pyi,sha256=K7DgSzU0F2q0W5j06ovR4iKMg20yYiL0vuqgA7Cde9Q,9730
+qcs_sdk_python-0.26.0.dist-info/METADATA,sha256=GcEHoXgy39L8WBsuGvfnqiRp_WaSR2b_yhWGqKXOQ8o,6304
+qcs_sdk_python-0.26.0.dist-info/WHEEL,sha256=MeHAddfhFE43Hox4HMNv5ysU_Px_FPIOurt9DcMoh1g,97
+qcs_sdk_python-0.26.0.dist-info/sboms/qcs.cyclonedx.json,sha256=ADZG5wZcIkYtuiQgusJJ4_2rf_2o8qTv88B8Ep3xKyk,636118
+qcs_sdk_python-0.26.0.dist-info/RECORD,,

qcs_sdk_python-0.26.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.12.6)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64