qcs-sdk-python 0.21.22-rc.0

Python bindings to qcs-sdk-rust
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

use std::time::Duration;

use pyo3::{exceptions::PyRuntimeError, pyfunction, PyResult};
use rigetti_pyo3::{
    create_init_submodule, py_function_sync_async, py_wrap_error, wrap_error, ToPythonError,
};

pub use result_data::{PyQpuResultData, PyReadoutValues, RawQpuReadoutData};

pub mod api;
pub(crate) mod experimental;
pub mod isa;
mod result_data;
pub mod translation;

use crate::client::PyQcsClient;

use self::result_data::PyMemoryValues;

create_init_submodule! {
    classes: [
        PyQpuResultData,
        RawQpuReadoutData,
        PyReadoutValues,
        PyMemoryValues
    ],
    errors: [
        ListQuantumProcessorsError
    ],
    funcs: [
        py_list_quantum_processors,
        py_list_quantum_processors_async
    ],
    submodules: [
        "api": api::init_submodule,
        "isa": isa::init_submodule,
        "translation": translation::init_submodule,
        "experimental": experimental::init_submodule
    ],
}

wrap_error!(RustListQuantumProcessorsError(
    qcs::qpu::ListQuantumProcessorsError
));
py_wrap_error!(
    api,
    RustListQuantumProcessorsError,
    ListQuantumProcessorsError,
    PyRuntimeError
);

py_function_sync_async! {
    #[pyfunction]
    #[pyo3(signature = (client = None, timeout = None))]
    async fn list_quantum_processors(
        client: Option<PyQcsClient>,
        timeout: Option<f64>,
    ) -> PyResult<Vec<String>> {
        let client = PyQcsClient::get_or_create_client(client);
        let timeout = timeout.map(Duration::from_secs_f64);
        qcs::qpu::list_quantum_processors(&client, timeout)
            .await
            .map_err(RustListQuantumProcessorsError::from)
            .map_err(RustListQuantumProcessorsError::to_py_err)
    }
}