10705682221

Committed 04 Sep 2024 04:24PM UTC coverage: 89.784% (-0.05%) from 89.835%

Build # 10705682221

Build Type

Pull #13087

github

Committed by

mergify[bot]

Commit Message

Bug fix in `HoareOptimizer` (#13083)

* bug fix, test, reno

* suggestions from code review; lint

(cherry picked from commit 576efcf14)

Pull Request Pull Request #13087: Bug fix in `HoareOptimizer` (backport #13083)

Run Details

7 of 7 new or added lines in 1 file covered. (100.0%)

45 existing lines in 4 files now uncovered.

66882 of 74492 relevant lines covered (89.78%)

233400.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.5

/crates/circuit/src/dag_node.rs

// This code is part of Qiskit.
//
// (C) Copyright IBM 2024
//
// This code is licensed under the Apache License, Version 2.0. You may
// obtain a copy of this license in the LICENSE.txt file in the root directory
// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
//
// Any modifications or derivative works of this code must retain this
// copyright notice, and modified files need to carry a notice indicating
// that they have been altered from the originals.

#[cfg(feature = "cache_pygates")]
use std::cell::RefCell;

use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
use crate::imports::QUANTUM_CIRCUIT;
use crate::operations::Operation;

use numpy::IntoPyArray;

use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList, PySequence, PyString, PyTuple};
use pyo3::{intern, IntoPy, PyObject, PyResult, ToPyObject};

/// Parent class for DAGOpNode, DAGInNode, and DAGOutNode.
#[pyclass(module = "qiskit._accelerate.circuit", subclass)]
#[derive(Clone, Debug)]
pub struct DAGNode {
    #[pyo3(get, set)]
    pub _node_id: isize,
}

#[pymethods]
impl DAGNode {
    #[new]
    #[pyo3(signature=(nid=-1))]
    fn new(nid: isize) -> Self {
        DAGNode { _node_id: nid }
    }

    fn __getstate__(&self) -> isize {
        self._node_id
    }

    fn __setstate__(&mut self, nid: isize) {
        self._node_id = nid;
    }

    fn __lt__(&self, other: &DAGNode) -> bool {
        self._node_id < other._node_id
    }

    fn __gt__(&self, other: &DAGNode) -> bool {
        self._node_id > other._node_id
    }

    fn __str__(_self: &Bound<DAGNode>) -> String {
        format!("{}", _self.as_ptr() as usize)
    }

    fn __hash__(&self, py: Python) -> PyResult<isize> {
        self._node_id.into_py(py).bind(py).hash()
    }
}

/// Object to represent an Instruction at a node in the DAGCircuit.
#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
pub struct DAGOpNode {
    pub instruction: CircuitInstruction,
    #[pyo3(get)]
    pub sort_key: PyObject,
}

#[pymethods]
impl DAGOpNode {
    #[new]
    #[pyo3(signature = (op, qargs=None, cargs=None, *, dag=None))]
    fn new(
        py: Python,
        op: &Bound<PyAny>,
        qargs: Option<&Bound<PySequence>>,
        cargs: Option<&Bound<PySequence>>,
        dag: Option<&Bound<PyAny>>,
    ) -> PyResult<(Self, DAGNode)> {
        let qargs =
            qargs.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;
        let cargs =
            cargs.map_or_else(|| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;

        let sort_key = match dag {
            Some(dag) => {
                let cache = dag
                    .getattr(intern!(py, "_key_cache"))?
                    .downcast_into_exact::<PyDict>()?;
                let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);
                match cache.get_item(&cache_key)? {
                    Some(key) => key,
                    None => {
                        let indices: PyResult<Vec<_>> = qargs
                            .iter()
                            .chain(cargs.iter())
                            .map(|bit| {
                                dag.call_method1(intern!(py, "find_bit"), (bit,))?
                                    .getattr(intern!(py, "index"))
                            })
                            .collect();
                        let index_strs: Vec<_> =
                            indices?.into_iter().map(|i| format!("{:04}", i)).collect();
                        let key = PyString::new_bound(py, index_strs.join(",").as_str());
                        cache.set_item(&cache_key, &key)?;
                        key.into_any()
                    }
                }
            }
            None => qargs.str()?.into_any(),
        };
        Ok((
            DAGOpNode {
                instruction: CircuitInstruction::py_new(
                    op,
                    Some(qargs.into_any()),
                    Some(cargs.into_any()),
                )?,
                sort_key: sort_key.unbind(),
            },
            DAGNode { _node_id: -1 },
        ))
    }

    #[pyo3(signature = (instruction, /, *, dag=None, deepcopy=false))]
    #[staticmethod]
    fn from_instruction(
        py: Python,
        mut instruction: CircuitInstruction,
        dag: Option<&Bound<PyAny>>,
        deepcopy: bool,
    ) -> PyResult<PyObject> {
        let qargs = instruction.qubits.bind(py);
        let cargs = instruction.clbits.bind(py);

        let sort_key = match dag {
            Some(dag) => {
                let cache = dag
                    .getattr(intern!(py, "_key_cache"))?
                    .downcast_into_exact::<PyDict>()?;
                let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);
                match cache.get_item(&cache_key)? {
                    Some(key) => key,
                    None => {
                        let indices: PyResult<Vec<_>> = qargs
                            .iter()
                            .chain(cargs.iter())
                            .map(|bit| {
                                dag.call_method1(intern!(py, "find_bit"), (bit,))?
                                    .getattr(intern!(py, "index"))
                            })
                            .collect();
                        let index_strs: Vec<_> =
                            indices?.into_iter().map(|i| format!("{:04}", i)).collect();
                        let key = PyString::new_bound(py, index_strs.join(",").as_str());
                        cache.set_item(&cache_key, &key)?;
                        key.into_any()
                    }
                }
            }
            None => qargs.str()?.into_any(),
        };
        if deepcopy {
            instruction.operation = instruction.operation.py_deepcopy(py, None)?;
            #[cfg(feature = "cache_pygates")]
            {
                *instruction.py_op.borrow_mut() = None;
            }
        }
        let base = PyClassInitializer::from(DAGNode { _node_id: -1 });
        let sub = base.add_subclass(DAGOpNode {
            instruction,
            sort_key: sort_key.unbind(),
        });
        Ok(Py::new(py, sub)?.to_object(py))
    }

    fn __reduce__(slf: PyRef<Self>) -> PyResult<PyObject> {
        let py = slf.py();
        let state = (slf.as_ref()._node_id, &slf.sort_key);
        Ok((
            py.get_type_bound::<Self>(),
            (
                slf.instruction.get_operation(py)?,
                &slf.instruction.qubits,
                &slf.instruction.clbits,
            ),
            state,
        )
            .into_py(py))
    }

    fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
        let (nid, sort_key): (isize, PyObject) = state.extract()?;
        slf.as_mut()._node_id = nid;
        slf.sort_key = sort_key;
        Ok(())
    }

    /// Get a `CircuitInstruction` that represents the same information as this `DAGOpNode`.  If
    /// `deepcopy`, any internal Python objects are deep-copied.
    ///
    /// Note: this ought to be a temporary method, while the DAG/QuantumCircuit converters still go
    /// via Python space; this still involves copy-out and copy-in of the data, whereas doing it all
    /// within Rust space could directly re-pack the instruction from a `DAGOpNode` to a
    /// `PackedInstruction` with no intermediate copy.
    #[pyo3(signature = (/, *, deepcopy=false))]
    fn _to_circuit_instruction(&self, py: Python, deepcopy: bool) -> PyResult<CircuitInstruction> {
        Ok(CircuitInstruction {
            operation: if deepcopy {
                self.instruction.operation.py_deepcopy(py, None)?
            } else {
                self.instruction.operation.clone()
            },
            qubits: self.instruction.qubits.clone_ref(py),
            clbits: self.instruction.clbits.clone_ref(py),
            params: self.instruction.params.clone(),
            extra_attrs: self.instruction.extra_attrs.clone(),
            #[cfg(feature = "cache_pygates")]
            py_op: RefCell::new(None),
        })
    }

    #[getter]
    fn get_op(&self, py: Python) -> PyResult<PyObject> {
        self.instruction.get_operation(py)
    }

    #[setter]
    fn set_op(&mut self, op: &Bound<PyAny>) -> PyResult<()> {
        let res = op.extract::<OperationFromPython>()?;
        self.instruction.operation = res.operation;
        self.instruction.params = res.params;
        self.instruction.extra_attrs = res.extra_attrs;
        #[cfg(feature = "cache_pygates")]
        {
            *self.instruction.py_op.borrow_mut() = Some(op.into_py(op.py()));
        }
        Ok(())
    }

    #[getter]
    fn num_qubits(&self) -> u32 {
        self.instruction.op().num_qubits()
    }

    #[getter]
    fn num_clbits(&self) -> u32 {
        self.instruction.op().num_clbits()
    }

    #[getter]
    fn get_qargs(&self, py: Python) -> Py<PyTuple> {
        self.instruction.qubits.clone_ref(py)
    }

    #[setter]
    fn set_qargs(&mut self, qargs: Py<PyTuple>) {
        self.instruction.qubits = qargs;
    }

    #[getter]
    fn get_cargs(&self, py: Python) -> Py<PyTuple> {
        self.instruction.clbits.clone_ref(py)
    }

    #[setter]
    fn set_cargs(&mut self, cargs: Py<PyTuple>) {
        self.instruction.clbits = cargs;
    }

    /// Returns the Instruction name corresponding to the op for this node
    #[getter]
    fn get_name(&self, py: Python) -> Py<PyString> {
        self.instruction.op().name().into_py(py)
    }

    #[getter]
    fn get_params(&self, py: Python) -> PyObject {
        self.instruction.params.to_object(py)
    }

    #[setter]
    fn set_params(&mut self, val: smallvec::SmallVec<[crate::operations::Param; 3]>) {
        self.instruction.params = val;
    }

    #[getter]
    fn matrix(&self, py: Python) -> Option<PyObject> {
        let matrix = self.instruction.op().matrix(&self.instruction.params);
        matrix.map(|mat| mat.into_pyarray_bound(py).into())
    }

    #[getter]
    fn label(&self) -> Option<&str> {
        self.instruction
            .extra_attrs
            .as_ref()
            .and_then(|attrs| attrs.label.as_deref())
    }

    #[getter]
    fn condition(&self, py: Python) -> Option<PyObject> {
        self.instruction
            .extra_attrs
            .as_ref()
            .and_then(|attrs| attrs.condition.as_ref().map(|x| x.clone_ref(py)))
    }

    #[getter]
    fn duration(&self, py: Python) -> Option<PyObject> {
        self.instruction
            .extra_attrs
            .as_ref()
            .and_then(|attrs| attrs.duration.as_ref().map(|x| x.clone_ref(py)))
    }

    #[getter]
    fn unit(&self) -> Option<&str> {
        self.instruction
            .extra_attrs
            .as_ref()
            .and_then(|attrs| attrs.unit.as_deref())
    }

    /// Is the :class:`.Operation` contained in this node a Qiskit standard gate?
    pub fn is_standard_gate(&self) -> bool {
        self.instruction.is_standard_gate()
    }

    /// Is the :class:`.Operation` contained in this node a subclass of :class:`.ControlledGate`?
    pub fn is_controlled_gate(&self, py: Python) -> PyResult<bool> {
        self.instruction.is_controlled_gate(py)
    }

    /// Is the :class:`.Operation` contained in this node a directive?
    pub fn is_directive(&self) -> bool {
        self.instruction.is_directive()
    }

    /// Is the :class:`.Operation` contained in this node a control-flow operation (i.e. an instance
    /// of :class:`.ControlFlowOp`)?
    pub fn is_control_flow(&self) -> bool {
        self.instruction.is_control_flow()
    }

    /// Does this node contain any :class:`.ParameterExpression` parameters?
    pub fn is_parameterized(&self) -> bool {
        self.instruction.is_parameterized()
    }

    #[setter]
    fn set_label(&mut self, val: Option<String>) {
        match self.instruction.extra_attrs.as_mut() {
            Some(attrs) => attrs.label = val,
            None => {
                if val.is_some() {
                    self.instruction.extra_attrs = Some(Box::new(
                        crate::circuit_instruction::ExtraInstructionAttributes {
                            label: val,
                            duration: None,
                            unit: None,
                            condition: None,
                        },
                    ))
                }
            }
        };
        if let Some(attrs) = &self.instruction.extra_attrs {
            if attrs.label.is_none()
                && attrs.duration.is_none()
                && attrs.unit.is_none()
                && attrs.condition.is_none()
            {
                self.instruction.extra_attrs = None;
            }
        }
    }

    #[getter]
    fn definition<'py>(&self, py: Python<'py>) -> PyResult<Option<Bound<'py, PyAny>>> {
        self.instruction
            .op()
            .definition(&self.instruction.params)
            .map(|data| {
                QUANTUM_CIRCUIT
                    .get_bound(py)
                    .call_method1(intern!(py, "_from_circuit_data"), (data,))
            })
            .transpose()
    }

    /// Sets the Instruction name corresponding to the op for this node
    #[setter]
    fn set_name(&mut self, py: Python, new_name: PyObject) -> PyResult<()> {
        let op = self.instruction.get_operation_mut(py)?.into_bound(py);
        op.setattr(intern!(py, "name"), new_name)?;
        self.instruction.operation = op.extract::<OperationFromPython>()?.operation;
        Ok(())
    }

    /// Returns a representation of the DAGOpNode
    fn __repr__(&self, py: Python) -> PyResult<String> {
        Ok(format!(
            "DAGOpNode(op={}, qargs={}, cargs={})",
            self.instruction.get_operation(py)?.bind(py).repr()?,
            self.instruction.qubits.bind(py).repr()?,
            self.instruction.clbits.bind(py).repr()?
        ))
    }
}

/// Object to represent an incoming wire node in the DAGCircuit.
#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
pub struct DAGInNode {
    #[pyo3(get)]
    wire: PyObject,
    #[pyo3(get)]
    sort_key: PyObject,
}

#[pymethods]
impl DAGInNode {
    #[new]
    fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
        Ok((
            DAGInNode {
                wire,
                sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),
            },
            DAGNode { _node_id: -1 },
        ))
    }

    fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
        let state = (slf.as_ref()._node_id, &slf.sort_key);
        (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)
    }

    fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
        let (nid, sort_key): (isize, PyObject) = state.extract()?;
        slf.as_mut()._node_id = nid;
        slf.sort_key = sort_key;
        Ok(())
    }

    /// Returns a representation of the DAGInNode
    fn __repr__(&self, py: Python) -> PyResult<String> {
        Ok(format!("DAGInNode(wire={})", self.wire.bind(py).repr()?))
    }
}

/// Object to represent an outgoing wire node in the DAGCircuit.
#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
pub struct DAGOutNode {
    #[pyo3(get)]
    wire: PyObject,
    #[pyo3(get)]
    sort_key: PyObject,
}

#[pymethods]
impl DAGOutNode {
    #[new]
    fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {
        Ok((
            DAGOutNode {
                wire,
                sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),
            },
            DAGNode { _node_id: -1 },
        ))
    }

    fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
        let state = (slf.as_ref()._node_id, &slf.sort_key);
        (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)
    }

    fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {
        let (nid, sort_key): (isize, PyObject) = state.extract()?;
        slf.as_mut()._node_id = nid;
        slf.sort_key = sort_key;
        Ok(())
    }

    /// Returns a representation of the DAGOutNode
    fn __repr__(&self, py: Python) -> PyResult<String> {
        Ok(format!("DAGOutNode(wire={})", self.wire.bind(py).repr()?))
    }
}

1	// This code is part of Qiskit.
2	//
3	// (C) Copyright IBM 2024
4	//
5	// This code is licensed under the Apache License, Version 2.0. You may
6	// obtain a copy of this license in the LICENSE.txt file in the root directory
7	// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	//
9	// Any modifications or derivative works of this code must retain this
10	// copyright notice, and modified files need to carry a notice indicating
11	// that they have been altered from the originals.
12
13	#[cfg(feature = "cache_pygates")]
14	use std::cell::RefCell;
15
16	use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
17	use crate::imports::QUANTUM_CIRCUIT;
18	use crate::operations::Operation;
19
20	use numpy::IntoPyArray;
21
22	use pyo3::prelude::*;
23	use pyo3::types::{PyDict, PyList, PySequence, PyString, PyTuple};
24	use pyo3::{intern, IntoPy, PyObject, PyResult, ToPyObject};
25
26	/// Parent class for DAGOpNode, DAGInNode, and DAGOutNode.
27	#[pyclass(module = "qiskit._accelerate.circuit", subclass)]	16,180,046✔
28	#[derive(Clone, Debug)]
29	pub struct DAGNode {
30	#[pyo3(get, set)]
31	pub _node_id: isize,
32	}
33
34	#[pymethods]	1,840,092✔
35	impl DAGNode {
36	#[new]
37	#[pyo3(signature=(nid=-1))]
38	fn new(nid: isize) -> Self {	×
39	DAGNode { _node_id: nid }	×
40	}	×
41
42	fn __getstate__(&self) -> isize {	×
43	self._node_id	×
44	}	×
45
46	fn __setstate__(&mut self, nid: isize) {	×
47	self._node_id = nid;	×
48	}	×
49
50	fn __lt__(&self, other: &DAGNode) -> bool {	×
51	self._node_id < other._node_id	×
52	}	×
53
54	fn __gt__(&self, other: &DAGNode) -> bool {	×
55	self._node_id > other._node_id	×
56	}	×
57
58	fn __str__(_self: &Bound<DAGNode>) -> String {	8✔
59	format!("{}", _self.as_ptr() as usize)	8✔
60	}	8✔
61
62	fn __hash__(&self, py: Python) -> PyResult<isize> {	1,840,084✔
63	self._node_id.into_py(py).bind(py).hash()	1,840,084✔
64	}	1,840,084✔
65	}
66
67	/// Object to represent an Instruction at a node in the DAGCircuit.
68	#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]	1,546,440✔
69	pub struct DAGOpNode {
70	pub instruction: CircuitInstruction,
71	#[pyo3(get)]
72	pub sort_key: PyObject,
73	}
74
75	#[pymethods]	50,102,046✔
76	impl DAGOpNode {
77	#[new]
78	#[pyo3(signature = (op, qargs=None, cargs=None, *, dag=None))]
79	fn new(	314,302✔
80	py: Python,	314,302✔
81	op: &Bound<PyAny>,	314,302✔
82	qargs: Option<&Bound<PySequence>>,	314,302✔
83	cargs: Option<&Bound<PySequence>>,	314,302✔
84	dag: Option<&Bound<PyAny>>,	314,302✔
85	) -> PyResult<(Self, DAGNode)> {	314,302✔
86	let qargs =	314,302✔
87	qargs.map_or_else(\|\| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;	314,302✔
88	let cargs =	314,302✔
89	cargs.map_or_else(\|\| Ok(PyTuple::empty_bound(py)), PySequenceMethods::to_tuple)?;	314,302✔
90
91	let sort_key = match dag {	314,302✔
92	Some(dag) => {	278,330✔
93	let cache = dag	278,330✔
94	.getattr(intern!(py, "_key_cache"))?	278,330✔
95	.downcast_into_exact::<PyDict>()?;	278,330✔
96	let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);	278,330✔
97	match cache.get_item(&cache_key)? {	278,330✔
98	Some(key) => key,	154,874✔
99	None => {
100	let indices: PyResult<Vec<_>> = qargs	123,456✔
101	.iter()	123,456✔
102	.chain(cargs.iter())	123,456✔
103	.map(\|bit\| {	239,186✔
104	dag.call_method1(intern!(py, "find_bit"), (bit,))?	239,186✔
105	.getattr(intern!(py, "index"))	239,186✔
106	})	239,186✔
107	.collect();	123,456✔
108	let index_strs: Vec<_> =	123,456✔
109	indices?.into_iter().map(\|i\| format!("{:04}", i)).collect();	239,186✔
110	let key = PyString::new_bound(py, index_strs.join(",").as_str());	123,456✔
111	cache.set_item(&cache_key, &key)?;	123,456✔
112	key.into_any()	123,456✔
113	}
114	}
115	}
116	None => qargs.str()?.into_any(),	35,972✔
117	};
118	Ok((
119	DAGOpNode {
120	instruction: CircuitInstruction::py_new(	314,302✔
121	op,	314,302✔
122	Some(qargs.into_any()),	314,302✔
123	Some(cargs.into_any()),	314,302✔
124	)?,	314,302✔
125	sort_key: sort_key.unbind(),	314,302✔
126	},	314,302✔
127	DAGNode { _node_id: -1 },	314,302✔
128	))
129	}	314,302✔
130
131	#[pyo3(signature = (instruction, /, *, dag=None, deepcopy=false))]
132	#[staticmethod]
133	fn from_instruction(	2,229,524✔
134	py: Python,	2,229,524✔
135	mut instruction: CircuitInstruction,	2,229,524✔
136	dag: Option<&Bound<PyAny>>,	2,229,524✔
137	deepcopy: bool,	2,229,524✔
138	) -> PyResult<PyObject> {	2,229,524✔
139	let qargs = instruction.qubits.bind(py);	2,229,524✔
140	let cargs = instruction.clbits.bind(py);	2,229,524✔
141
142	let sort_key = match dag {	2,229,524✔
143	Some(dag) => {	1,586,702✔
144	let cache = dag	1,586,702✔
145	.getattr(intern!(py, "_key_cache"))?	1,586,702✔
146	.downcast_into_exact::<PyDict>()?;	1,586,702✔
147	let cache_key = PyTuple::new_bound(py, [&qargs, &cargs]);	1,586,702✔
148	match cache.get_item(&cache_key)? {	1,586,702✔
149	Some(key) => key,	1,026,236✔
150	None => {
151	let indices: PyResult<Vec<_>> = qargs	560,466✔
152	.iter()	560,466✔
153	.chain(cargs.iter())	560,466✔
154	.map(\|bit\| {	858,858✔
155	dag.call_method1(intern!(py, "find_bit"), (bit,))?	858,858✔
156	.getattr(intern!(py, "index"))	858,858✔
157	})	858,858✔
158	.collect();	560,466✔
159	let index_strs: Vec<_> =	560,466✔
160	indices?.into_iter().map(\|i\| format!("{:04}", i)).collect();	858,858✔
161	let key = PyString::new_bound(py, index_strs.join(",").as_str());	560,466✔
162	cache.set_item(&cache_key, &key)?;	560,466✔
163	key.into_any()	560,466✔
164	}
165	}
166	}
167	None => qargs.str()?.into_any(),	642,822✔
168	};
169	if deepcopy {	2,229,524✔
170	instruction.operation = instruction.operation.py_deepcopy(py, None)?;	928,762✔
171	#[cfg(feature = "cache_pygates")]
172	{	928,762✔
173	*instruction.py_op.borrow_mut() = None;	928,762✔
174	}	928,762✔
175	}	1,300,762✔
176	let base = PyClassInitializer::from(DAGNode { _node_id: -1 });	2,229,524✔
177	let sub = base.add_subclass(DAGOpNode {	2,229,524✔
178	instruction,	2,229,524✔
179	sort_key: sort_key.unbind(),	2,229,524✔
180	});	2,229,524✔
181	Ok(Py::new(py, sub)?.to_object(py))	2,229,524✔
182	}	2,229,524✔
183
184	fn __reduce__(slf: PyRef<Self>) -> PyResult<PyObject> {	27,370✔
185	let py = slf.py();	27,370✔
186	let state = (slf.as_ref()._node_id, &slf.sort_key);	27,370✔
187	Ok((	27,370✔
188	py.get_type_bound::<Self>(),	27,370✔
189	(	27,370✔
190	slf.instruction.get_operation(py)?,	27,370✔
191	&slf.instruction.qubits,	27,370✔
192	&slf.instruction.clbits,	27,370✔
193	),	27,370✔
194	state,	27,370✔
195	)	27,370✔
196	.into_py(py))	27,370✔
197	}	27,370✔
198
199	fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {	27,370✔
200	let (nid, sort_key): (isize, PyObject) = state.extract()?;	27,370✔
201	slf.as_mut()._node_id = nid;	27,370✔
202	slf.sort_key = sort_key;	27,370✔
203	Ok(())	27,370✔
204	}	27,370✔
205
206	/// Get a `CircuitInstruction` that represents the same information as this `DAGOpNode`. If
207	/// `deepcopy`, any internal Python objects are deep-copied.
208	///
209	/// Note: this ought to be a temporary method, while the DAG/QuantumCircuit converters still go
210	/// via Python space; this still involves copy-out and copy-in of the data, whereas doing it all
211	/// within Rust space could directly re-pack the instruction from a `DAGOpNode` to a
212	/// `PackedInstruction` with no intermediate copy.
213	#[pyo3(signature = (/, *, deepcopy=false))]
214	fn _to_circuit_instruction(&self, py: Python, deepcopy: bool) -> PyResult<CircuitInstruction> {	1,599,202✔
215	Ok(CircuitInstruction {	1,599,202✔
216	operation: if deepcopy {	1,599,202✔
217	self.instruction.operation.py_deepcopy(py, None)?	54,134✔
218	} else {
219	self.instruction.operation.clone()	1,545,068✔
220	},
221	qubits: self.instruction.qubits.clone_ref(py),	1,599,202✔
222	clbits: self.instruction.clbits.clone_ref(py),	1,599,202✔
223	params: self.instruction.params.clone(),	1,599,202✔
224	extra_attrs: self.instruction.extra_attrs.clone(),	1,599,202✔
225	#[cfg(feature = "cache_pygates")]	1,599,202✔
226	py_op: RefCell::new(None),	1,599,202✔
227	})
228	}	1,599,202✔
229
230	#[getter]
231	fn get_op(&self, py: Python) -> PyResult<PyObject> {	3,579,560✔
232	self.instruction.get_operation(py)	3,579,560✔
233	}	3,579,560✔
234
235	#[setter]
236	fn set_op(&mut self, op: &Bound<PyAny>) -> PyResult<()> {	26,260✔
237	let res = op.extract::<OperationFromPython>()?;	26,260✔
238	self.instruction.operation = res.operation;	26,260✔
239	self.instruction.params = res.params;	26,260✔
240	self.instruction.extra_attrs = res.extra_attrs;	26,260✔
241	#[cfg(feature = "cache_pygates")]	26,260✔
242	{	26,260✔
243	*self.instruction.py_op.borrow_mut() = Some(op.into_py(op.py()));	26,260✔
244	}	26,260✔
245	Ok(())	26,260✔
246	}	26,260✔
247
248	#[getter]
249	fn num_qubits(&self) -> u32 {	4,433,048✔
250	self.instruction.op().num_qubits()	4,433,048✔
251	}	4,433,048✔
252
253	#[getter]
254	fn num_clbits(&self) -> u32 {	×
255	self.instruction.op().num_clbits()	×
256	}	×
257
258	#[getter]
259	fn get_qargs(&self, py: Python) -> Py<PyTuple> {	8,296,148✔
260	self.instruction.qubits.clone_ref(py)	8,296,148✔
261	}	8,296,148✔
262
263	#[setter]
264	fn set_qargs(&mut self, qargs: Py<PyTuple>) {	377,328✔
265	self.instruction.qubits = qargs;	377,328✔
266	}	377,328✔
267
268	#[getter]
269	fn get_cargs(&self, py: Python) -> Py<PyTuple> {	4,587,508✔
270	self.instruction.clbits.clone_ref(py)	4,587,508✔
271	}	4,587,508✔
272
273	#[setter]
274	fn set_cargs(&mut self, cargs: Py<PyTuple>) {	331,848✔
275	self.instruction.clbits = cargs;	331,848✔
276	}	331,848✔
277
278	/// Returns the Instruction name corresponding to the op for this node
279	#[getter]
280	fn get_name(&self, py: Python) -> Py<PyString> {	11,095,116✔
281	self.instruction.op().name().into_py(py)	11,095,116✔
282	}	11,095,116✔
283
284	#[getter]
285	fn get_params(&self, py: Python) -> PyObject {	589,016✔
286	self.instruction.params.to_object(py)	589,016✔
287	}	589,016✔
288
289	#[setter]
290	fn set_params(&mut self, val: smallvec::SmallVec<[crate::operations::Param; 3]>) {	45,550✔
291	self.instruction.params = val;	45,550✔
292	}	45,550✔
293
294	#[getter]
295	fn matrix(&self, py: Python) -> Option<PyObject> {	38,476✔
296	let matrix = self.instruction.op().matrix(&self.instruction.params);	38,476✔
297	matrix.map(\|mat\| mat.into_pyarray_bound(py).into())	38,476✔
298	}	38,476✔
299
300	#[getter]
301	fn label(&self) -> Option<&str> {	98,456✔
302	self.instruction	98,456✔
303	.extra_attrs	98,456✔
304	.as_ref()	98,456✔
305	.and_then(\|attrs\| attrs.label.as_deref())	98,456✔
306	}	98,456✔
307
308	#[getter]
309	fn condition(&self, py: Python) -> Option<PyObject> {	3,474,384✔
310	self.instruction	3,474,384✔
311	.extra_attrs	3,474,384✔
312	.as_ref()	3,474,384✔
313	.and_then(\|attrs\| attrs.condition.as_ref().map(\|x\| x.clone_ref(py)))	3,474,384✔
314	}	3,474,384✔
315
316	#[getter]
317	fn duration(&self, py: Python) -> Option<PyObject> {	×
318	self.instruction	×
319	.extra_attrs	×
320	.as_ref()	×
321	.and_then(\|attrs\| attrs.duration.as_ref().map(\|x\| x.clone_ref(py)))	×
322	}	×
323
324	#[getter]
325	fn unit(&self) -> Option<&str> {	×
326	self.instruction	×
327	.extra_attrs	×
328	.as_ref()	×
329	.and_then(\|attrs\| attrs.unit.as_deref())	×
330	}	×
331
332	/// Is the :class:`.Operation` contained in this node a Qiskit standard gate?
333	pub fn is_standard_gate(&self) -> bool {	6,937,430✔
334	self.instruction.is_standard_gate()	6,937,430✔
335	}	6,937,430✔
336
337	/// Is the :class:`.Operation` contained in this node a subclass of :class:`.ControlledGate`?
338	pub fn is_controlled_gate(&self, py: Python) -> PyResult<bool> {	252,000✔
339	self.instruction.is_controlled_gate(py)	252,000✔
340	}	252,000✔
341
342	/// Is the :class:`.Operation` contained in this node a directive?
343	pub fn is_directive(&self) -> bool {	748,792✔
344	self.instruction.is_directive()	748,792✔
345	}	748,792✔
346
347	/// Is the :class:`.Operation` contained in this node a control-flow operation (i.e. an instance
348	/// of :class:`.ControlFlowOp`)?
349	pub fn is_control_flow(&self) -> bool {	973,192✔
350	self.instruction.is_control_flow()	973,192✔
351	}	973,192✔
352
353	/// Does this node contain any :class:`.ParameterExpression` parameters?
354	pub fn is_parameterized(&self) -> bool {	52,314✔
355	self.instruction.is_parameterized()	52,314✔
356	}	52,314✔
357
358	#[setter]
359	fn set_label(&mut self, val: Option<String>) {	×
360	match self.instruction.extra_attrs.as_mut() {	×
361	Some(attrs) => attrs.label = val,	×
362	None => {
363	if val.is_some() {	×
364	self.instruction.extra_attrs = Some(Box::new(	×
365	crate::circuit_instruction::ExtraInstructionAttributes {	×
366	label: val,	×
367	duration: None,	×
368	unit: None,	×
369	condition: None,	×
370	},	×
371	))	×
372	}	×
373	}
374	};
375	if let Some(attrs) = &self.instruction.extra_attrs {	×
376	if attrs.label.is_none()	×
377	&& attrs.duration.is_none()	×
378	&& attrs.unit.is_none()	×
379	&& attrs.condition.is_none()	×
380	{	×
381	self.instruction.extra_attrs = None;	×
382	}	×
383	}	×
384	}	×
385
386	#[getter]
387	fn definition<'py>(&self, py: Python<'py>) -> PyResult<Option<Bound<'py, PyAny>>> {	2,492✔
388	self.instruction	2,492✔
389	.op()	2,492✔
390	.definition(&self.instruction.params)	2,492✔
391	.map(\|data\| {	2,492✔
392	QUANTUM_CIRCUIT	2,492✔
393	.get_bound(py)	2,492✔
394	.call_method1(intern!(py, "_from_circuit_data"), (data,))	2,492✔
395	})	2,492✔
396	.transpose()	2,492✔
397	}	2,492✔
398
399	/// Sets the Instruction name corresponding to the op for this node
400	#[setter]
UNCOV 401	fn set_name(&mut self, py: Python, new_name: PyObject) -> PyResult<()> {	×
UNCOV 402	let op = self.instruction.get_operation_mut(py)?.into_bound(py);	×
UNCOV 403	op.setattr(intern!(py, "name"), new_name)?;	×
UNCOV 404	self.instruction.operation = op.extract::<OperationFromPython>()?.operation;	×
UNCOV 405	Ok(())	×
UNCOV 406	}	×
407
408	/// Returns a representation of the DAGOpNode
409	fn __repr__(&self, py: Python) -> PyResult<String> {	4✔
410	Ok(format!(	4✔
411	"DAGOpNode(op={}, qargs={}, cargs={})",	4✔
412	self.instruction.get_operation(py)?.bind(py).repr()?,	4✔
413	self.instruction.qubits.bind(py).repr()?,	4✔
414	self.instruction.clbits.bind(py).repr()?	4✔
415	))
416	}	4✔
417	}
418
419	/// Object to represent an incoming wire node in the DAGCircuit.
420	#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]	1,604,752✔
421	pub struct DAGInNode {
422	#[pyo3(get)]
423	wire: PyObject,
424	#[pyo3(get)]
425	sort_key: PyObject,
426	}
427
428	#[pymethods]	1,331,926✔
429	impl DAGInNode {
430	#[new]
431	fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {	1,319,636✔
432	Ok((	1,319,636✔
433	DAGInNode {	1,319,636✔
434	wire,	1,319,636✔
435	sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),	1,319,636✔
436	},	1,319,636✔
437	DAGNode { _node_id: -1 },	1,319,636✔
438	))
439	}	1,319,636✔
440
441	fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {	6,144✔
442	let state = (slf.as_ref()._node_id, &slf.sort_key);	6,144✔
443	(py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)	6,144✔
444	}	6,144✔
445
446	fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {	6,144✔
447	let (nid, sort_key): (isize, PyObject) = state.extract()?;	6,144✔
448	slf.as_mut()._node_id = nid;	6,144✔
449	slf.sort_key = sort_key;	6,144✔
450	Ok(())	6,144✔
451	}	6,144✔
452
453	/// Returns a representation of the DAGInNode
454	fn __repr__(&self, py: Python) -> PyResult<String> {	2✔
455	Ok(format!("DAGInNode(wire={})", self.wire.bind(py).repr()?))	2✔
456	}	2✔
457	}
458
459	/// Object to represent an outgoing wire node in the DAGCircuit.
460	#[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]	857,862✔
461	pub struct DAGOutNode {
462	#[pyo3(get)]
463	wire: PyObject,
464	#[pyo3(get)]
465	sort_key: PyObject,
466	}
467
468	#[pymethods]	1,331,926✔
469	impl DAGOutNode {
470	#[new]
471	fn new(py: Python, wire: PyObject) -> PyResult<(Self, DAGNode)> {	1,319,636✔
472	Ok((	1,319,636✔
473	DAGOutNode {	1,319,636✔
474	wire,	1,319,636✔
475	sort_key: PyList::empty_bound(py).str()?.into_any().unbind(),	1,319,636✔
476	},	1,319,636✔
477	DAGNode { _node_id: -1 },	1,319,636✔
478	))
479	}	1,319,636✔
480
481	fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {	6,144✔
482	let state = (slf.as_ref()._node_id, &slf.sort_key);	6,144✔
483	(py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)	6,144✔
484	}	6,144✔
485
486	fn __setstate__(mut slf: PyRefMut<Self>, state: &Bound<PyAny>) -> PyResult<()> {	6,144✔
487	let (nid, sort_key): (isize, PyObject) = state.extract()?;	6,144✔
488	slf.as_mut()._node_id = nid;	6,144✔
489	slf.sort_key = sort_key;	6,144✔
490	Ok(())	6,144✔
491	}	6,144✔
492
493	/// Returns a representation of the DAGOutNode
494	fn __repr__(&self, py: Python) -> PyResult<String> {	2✔
495	Ok(format!("DAGOutNode(wire={})", self.wire.bind(py).repr()?))	2✔
496	}	2✔
497	}

Qiskit / qiskit / 10705682221

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous