qcs 0.26.1

High level interface for running Quil on a QPU
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

# 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, RegisterMap
from qcs_sdk.client import QCSClient
from . import api
from . import experimental
from . import isa
from . import translation

class ListQuantumProcessorsError(QcsSdkError):
    r"""
    API Errors encountered when trying to list available quantum processors.
    """
    ...

class MemoryValues:
    r"""
    A row of data containing the contents of a memory region at the end of a job.
    
    There is a variant for each possible type the memory region could be.
    """
    def __getnewargs__(self) -> tuple[builtins.list[builtins.int] | builtins.list[builtins.float]]: ...
    def __new__(cls, values: typing.Sequence[builtins.int] | typing.Sequence[builtins.float]) -> MemoryValues: ...
    def inner(self) -> builtins.list[builtins.int] | builtins.list[builtins.float]: ...
    @typing.final
    class Binary(MemoryValues):
        r"""
        Values that correspond to a memory region declared with the BIT or OCTET data type.
        """
        __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]) -> MemoryValues.Binary: ...
    
    @typing.final
    class Integer(MemoryValues):
        r"""
        Values that correspond to a memory region declared with the INTEGER data type.
        """
        __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]) -> MemoryValues.Integer: ...
    
    @typing.final
    class Real(MemoryValues):
        r"""
        Values that correspond to a memory region declared with the REAL data type.
        """
        __match_args__ = ("_0",)
        @property
        def _0(self) -> builtins.list[builtins.float]: ...
        def __getitem__(self, key: builtins.int) -> typing.Any: ...
        def __len__(self) -> builtins.int: ...
        def __new__(cls, _0: typing.Sequence[builtins.float]) -> MemoryValues.Real: ...
    

@typing.final
class QPUResultData:
    r"""
    Encapsulates data returned from the QPU after executing a job.
    
    `QpuResultData` contains "mappings", which map declared memory regions
    in a program (ie. "ro[0]") to that region's readout key in `QpuResultData.readout_values`.
    `readout_values` maps those readout keys to the values emitted for that region
    across all shots.
    
    Read more about QPU readout data in the
    [QCS Documentation](https://docs.rigetti.com/qcs/guides/qpus-vs-qvms#qpu-readout-data)
    """
    @property
    def mappings(self) -> builtins.dict[builtins.str, builtins.str]:
        r"""
        Mappings of a memory region (ie. "ro[0]") to its key name in `readout_values` (ie. "q0").
        """
    @property
    def memory_values(self) -> builtins.dict[builtins.str, MemoryValues]:
        r"""
        The final contents of each memory region, keyed on region name.
        """
    @property
    def readout_values(self) -> builtins.dict[builtins.str, ReadoutValues]:
        r"""
        Mapping of a readout values identifier (ie. "q0") to a set of `ReadoutValues`.
        """
    def __getnewargs__(self) -> tuple[builtins.dict[builtins.str, builtins.str], builtins.dict[builtins.str, ReadoutValues], builtins.dict[builtins.str, MemoryValues]]: ...
    def __new__(cls, mappings: typing.Mapping[builtins.str, builtins.str], readout_values: typing.Mapping[builtins.str, ReadoutValues], memory_values: typing.Mapping[builtins.str, MemoryValues]) -> QPUResultData:
        r"""
        Construct a new `QPUResultData` from mappings and values.
        """
    def __repr__(self) -> builtins.str:
        r"""
        Implements `__repr__` for Python in terms of the Rust
        [`Debug`](std::fmt::Debug) implementation.
        """
    def to_raw_readout_data(self) -> RawQPUReadoutData:
        r"""
        Get the raw readout data as a flattened structure.
        """
    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 execution data for any of the
        registers would result in a jagged matrix.
        [`QpuResultData`] data is captured per measure,
        meaning a value is returned for every measure to a memory reference, not just once per shot.
        
        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 RawQPUReadoutData:
    r"""
    A wrapper type for data returned by the QPU in a more flat structure than
    [`QpuResultData`] offers. This makes it more convenient to work with
    the data if you don't care what type of number the readout values for
    each register contains.
    """
    @property
    def mappings(self) -> builtins.dict[builtins.str, builtins.str]: ...
    @property
    def memory_values(self) -> builtins.dict[builtins.str, list]: ...
    @property
    def readout_values(self) -> builtins.dict[builtins.str, list]: ...
    def __repr__(self) -> builtins.str:
        r"""
        Implements `__repr__` for Python in terms of the Rust
        [`Debug`](std::fmt::Debug) implementation.
        """

class ReadoutValues:
    r"""
    A row of readout values from the QPU.
    
    Each row contains all the values emitted to a memory reference across all shots.
    There is a variant for each possible type the list of readout values could be.
    """
    def __getnewargs__(self) -> tuple[builtins.list[builtins.int] | builtins.list[builtins.float] | builtins.list[builtins.complex]]: ...
    def __new__(cls, values: typing.Sequence[builtins.int] | typing.Sequence[builtins.float] | typing.Sequence[builtins.complex]) -> ReadoutValues: ...
    def inner(self) -> builtins.list[builtins.int] | builtins.list[builtins.float] | builtins.list[builtins.complex]: ...
    @typing.final
    class Complex(ReadoutValues):
        r"""
        Complex readout values
        """
        __match_args__ = ("_0",)
        @property
        def _0(self) -> builtins.list[builtins.complex]: ...
        def __getitem__(self, key: builtins.int) -> typing.Any: ...
        def __len__(self) -> builtins.int: ...
        def __new__(cls, _0: typing.Sequence[builtins.complex]) -> ReadoutValues.Complex: ...
    
    @typing.final
    class Integer(ReadoutValues):
        r"""
        Integer readout values
        """
        __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]) -> ReadoutValues.Integer: ...
    
    @typing.final
    class Real(ReadoutValues):
        r"""
        Real numbered readout values
        """
        __match_args__ = ("_0",)
        @property
        def _0(self) -> builtins.list[builtins.float]: ...
        def __getitem__(self, key: builtins.int) -> typing.Any: ...
        def __len__(self) -> builtins.int: ...
        def __new__(cls, _0: typing.Sequence[builtins.float]) -> ReadoutValues.Real: ...
    

def list_quantum_processors(client: typing.Optional[QCSClient] = None, timeout: typing.Optional[builtins.float] = None) -> builtins.list[builtins.str]:
    r"""
    Returns all available Quantum Processor (QPU) IDs.
    
    :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.
    
    :raises ListQuantumProcessorsError: If the request to list available QPU IDs failed.
    """

def list_quantum_processors_async(client: typing.Optional[QCSClient] = None, timeout: typing.Optional[builtins.float] = None) -> collections.abc.Awaitable[builtins.list[builtins.str]]:
    r"""
    Returns all available Quantum Processor (QPU) IDs.
    
    :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.
    
    :raises ListQuantumProcessorsError: If the request to list available QPU IDs failed.
    """