quil/instruction/
calibration.rs

1use quil_rs::{
2    expression::Expression,
3    instruction::{
4        Calibration, CalibrationIdentifier, GateModifier, Instruction,
5        MeasureCalibrationDefinition, MeasureCalibrationIdentifier, Qubit,
6    },
7};
8
9use rigetti_pyo3::{
10    impl_repr, py_wrap_data_struct,
11    pyo3::{pymethods, types::PyString, Py, PyResult, Python},
12    PyTryFrom, PyWrapper, ToPythonError,
13};
14
15use crate::{
16    expression::PyExpression,
17    impl_copy_for_instruction, impl_eq, impl_pickle_for_instruction, impl_to_quil,
18    instruction::{PyGateModifier, PyInstruction, PyQubit},
19    validation::identifier::RustIdentifierValidationError,
20};
21
22py_wrap_data_struct! {
23    #[derive(Debug, PartialEq)]
24    #[pyo3(subclass, module = "quil.instructions")]
25    PyCalibration(Calibration) as "Calibration" {
26        identifier: CalibrationIdentifier => PyCalibrationIdentifier,
27        instructions: Vec<Instruction> => Vec<PyInstruction>
28    }
29}
30impl_repr!(PyCalibration);
31impl_to_quil!(PyCalibration);
32impl_copy_for_instruction!(PyCalibration);
33impl_eq!(PyCalibration);
34impl_pickle_for_instruction!(PyCalibration);
35
36#[pymethods]
37impl PyCalibration {
38    #[new]
39    pub fn new(
40        py: Python<'_>,
41        identifier: PyCalibrationIdentifier,
42        instructions: Vec<PyInstruction>,
43    ) -> PyResult<Self> {
44        Ok(Self(
45            Calibration::new(
46                CalibrationIdentifier::py_try_from(py, &identifier)?,
47                Vec::<Instruction>::py_try_from(py, &instructions)?,
48            )
49            .map_err(RustIdentifierValidationError::from)
50            .map_err(RustIdentifierValidationError::to_py_err)?,
51        ))
52    }
53
54    #[getter]
55    pub fn name(&self) -> &str {
56        &self.as_inner().identifier.name
57    }
58
59    #[getter]
60    pub fn parameters(&self) -> Vec<PyExpression> {
61        self.as_inner()
62            .identifier
63            .parameters
64            .clone()
65            .into_iter()
66            .map(Into::into)
67            .collect()
68    }
69
70    #[getter]
71    pub fn qubits(&self) -> Vec<PyQubit> {
72        self.as_inner()
73            .identifier
74            .qubits
75            .clone()
76            .into_iter()
77            .map(Into::into)
78            .collect()
79    }
80
81    #[getter]
82    pub fn modifiers(&self) -> Vec<PyGateModifier> {
83        self.as_inner()
84            .identifier
85            .modifiers
86            .clone()
87            .into_iter()
88            .map(Into::into)
89            .collect()
90    }
91}
92
93py_wrap_data_struct! {
94    #[derive(Debug, PartialEq)]
95    #[pyo3(subclass)]
96    PyCalibrationIdentifier(CalibrationIdentifier) as "CalibrationIdentifier" {
97        modifiers: Vec<GateModifier> => Vec<PyGateModifier>,
98        name: String => Py<PyString>,
99        parameters: Vec<Expression> => Vec<PyExpression>,
100        qubits: Vec<Qubit> => Vec<PyQubit>
101    }
102}
103impl_repr!(PyCalibrationIdentifier);
104impl_to_quil!(PyCalibrationIdentifier);
105impl_copy_for_instruction!(PyCalibrationIdentifier);
106impl_eq!(PyCalibrationIdentifier);
107
108#[pymethods]
109impl PyCalibrationIdentifier {
110    #[new]
111    pub fn new(
112        py: Python<'_>,
113        name: &str,
114        parameters: Vec<PyExpression>,
115        qubits: Vec<PyQubit>,
116        modifiers: Vec<PyGateModifier>,
117    ) -> PyResult<Self> {
118        Ok(Self(
119            CalibrationIdentifier::new(
120                name.to_string(),
121                Vec::<GateModifier>::py_try_from(py, &modifiers)?,
122                Vec::<Expression>::py_try_from(py, &parameters)?,
123                Vec::<Qubit>::py_try_from(py, &qubits)?,
124            )
125            .map_err(RustIdentifierValidationError::from)
126            .map_err(RustIdentifierValidationError::to_py_err)?,
127        ))
128    }
129}
130
131py_wrap_data_struct! {
132    #[derive(Debug, PartialEq)]
133    #[pyo3(subclass, module = "quil.instructions")]
134    PyMeasureCalibrationDefinition(MeasureCalibrationDefinition) as "MeasureCalibrationDefinition" {
135        identifier: MeasureCalibrationIdentifier => PyMeasureCalibrationIdentifier,
136        instructions: Vec<Instruction> => Vec<PyInstruction>
137    }
138}
139impl_repr!(PyMeasureCalibrationDefinition);
140impl_to_quil!(PyMeasureCalibrationDefinition);
141impl_copy_for_instruction!(PyMeasureCalibrationDefinition);
142impl_eq!(PyMeasureCalibrationDefinition);
143impl_pickle_for_instruction!(PyMeasureCalibrationDefinition);
144
145#[pymethods]
146impl PyMeasureCalibrationDefinition {
147    #[new]
148    #[pyo3(signature = (identifier, instructions))]
149    pub fn new(
150        py: Python<'_>,
151        identifier: PyMeasureCalibrationIdentifier,
152        instructions: Vec<PyInstruction>,
153    ) -> PyResult<Self> {
154        Ok(Self(MeasureCalibrationDefinition::new(
155            MeasureCalibrationIdentifier::py_try_from(py, &identifier)?,
156            Vec::<Instruction>::py_try_from(py, &instructions)?,
157        )))
158    }
159
160    #[getter]
161    pub fn qubit(&self) -> Option<PyQubit> {
162        self.as_inner().identifier.qubit.clone().map(Into::into)
163    }
164
165    #[getter]
166    pub fn parameter(&self) -> String {
167        self.as_inner().identifier.parameter.clone()
168    }
169}
170
171py_wrap_data_struct! {
172    #[derive(Debug, PartialEq)]
173    #[pyo3(subclass)]
174    PyMeasureCalibrationIdentifier(MeasureCalibrationIdentifier) as "MeasureCalibrationIdentifier" {
175        qubit: Option<Qubit> => Option<PyQubit>,
176        parameter: String => Py<PyString>
177    }
178}
179impl_repr!(PyMeasureCalibrationIdentifier);
180impl_to_quil!(PyMeasureCalibrationIdentifier);
181impl_copy_for_instruction!(PyMeasureCalibrationIdentifier);
182impl_eq!(PyMeasureCalibrationIdentifier);
183
184#[pymethods]
185impl PyMeasureCalibrationIdentifier {
186    #[new]
187    #[pyo3(signature = (qubit, parameter))]
188    pub fn new(py: Python<'_>, qubit: Option<PyQubit>, parameter: String) -> PyResult<Self> {
189        Ok(Self(MeasureCalibrationIdentifier::new(
190            Option::<Qubit>::py_try_from(py, &qubit)?,
191            parameter,
192        )))
193    }
194}
quil/instruction/calibration.rs

quil/instruction/
calibration.rs
