[WIP] Split PyDAGCircuit from DAGCircuit

crates/accelerate/src/circuit_duration.rs

@@ -13,7 +13,7 @@
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
-use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType, Wire};
+use qiskit_circuit::dag_circuit::{NodeType, PyDAGCircuit, Wire};
 use qiskit_circuit::operations::{DelayUnit, Operation, OperationRef, Param, StandardInstruction};
 
 use qiskit_transpiler::target::Target;
@@ -26,16 +26,16 @@ use rustworkx_core::petgraph::visit::{EdgeRef, IntoEdgeReferences};
 
 /// Estimate the duration of a scheduled circuit in seconds
 #[pyfunction]
-pub(crate) fn compute_estimated_duration(dag: &DAGCircuit, target: &Target) -> PyResult<f64> {
+pub(crate) fn compute_estimated_duration(dag: &PyDAGCircuit, target: &Target) -> PyResult<f64> {
     let dt = target.dt;
 
     let get_duration =
         |edge: <&StableDiGraph<NodeType, Wire> as IntoEdgeReferences>::EdgeRef| -> PyResult<f64> {
-            let node_weight = &dag[edge.target()];
+            let node_weight = &dag.dag_circuit[edge.target()];
             match node_weight {
                 NodeType::Operation(inst) => {
                     let name = inst.op.name();
-                    let qubits = dag.get_qargs(inst.qubits);
+                    let qubits = dag.dag_circuit.get_qargs(inst.qubits);
                     let physical_qubits: Vec<PhysicalQubit> =
                         qubits.iter().map(|x| PhysicalQubit::new(x.0)).collect();
 
@@ -91,7 +91,7 @@ pub(crate) fn compute_estimated_duration(dag: &DAGCircuit, target: &Target) -> P
                 )),
             }
         };
-    match longest_path(dag.dag(), get_duration)? {
+    match longest_path(dag.dag_circuit.dag(), get_duration)? {
         Some((_, weight)) => Ok(weight),
         None => Err(QiskitError::new_err("Invalid circuit provided")),
     }

crates/accelerate/src/twirling.rs

@@ -342,7 +342,7 @@ fn generate_twirled_circuit(
         }
     }
     if optimizer_target.is_some() {
-        let mut dag = DAGCircuit::from_circuit_data(&out_circ, false, None, None, None, None)?;
+        let mut dag = DAGCircuit::from_circuit_data(&out_circ, false, None, None)?;
         run_optimize_1q_gates_decomposition(&mut dag, optimizer_target, None, None)?;
         dag_to_circuit(&dag, false)
     } else {

crates/cext/src/dag.rs

@@ -125,7 +125,7 @@ pub unsafe extern "C" fn qk_dag_num_qubits(dag: *const DAGCircuit) -> u32 {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let dag = unsafe { const_ptr_as_ref(dag) };
 
-    dag.num_qubits() as u32
+    dag.qubits().len() as u32
 }
 
 /// @ingroup QkDag
@@ -154,7 +154,7 @@ pub unsafe extern "C" fn qk_dag_num_clbits(dag: *const DAGCircuit) -> u32 {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let dag = unsafe { const_ptr_as_ref(dag) };
 
-    dag.num_clbits() as u32
+    dag.clbits().len() as u32
 }
 
 /// @ingroup QkDag

crates/cext/src/transpiler/passes/basis_translator.rs

@@ -70,7 +70,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_basis_translator(
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let target = unsafe { const_ptr_as_ref(target) };
 
-    let dag = DAGCircuit::from_circuit_data(circ_from_ptr, false, None, None, None, None)
+    let dag = DAGCircuit::from_circuit_data(circ_from_ptr, false, None, None)
         .expect("Circuit to DAG conversion failed");
 
     let mut equiv_lib = generate_standard_equivalence_library();

crates/cext/src/transpiler/passes/commutative_cancellation.rs

@@ -72,7 +72,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_commutative_cancellation(
             "Invalid value provided for approximation degree, only NAN or values between 0.0 and 1.0 inclusive are valid"
         );
     }
-    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(_) => panic!("Internal circuit -> DAG conversion failed"),
     };

crates/cext/src/transpiler/passes/consolidate_blocks.rs

@@ -55,7 +55,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_consolidate_blocks(
     } else {
         approximation_degree
     };
-    let mut circ_as_dag = DAGCircuit::from_circuit_data(circuit, true, None, None, None, None)
+    let mut circ_as_dag = DAGCircuit::from_circuit_data(circuit, true, None, None)
         .expect("Error while converting from CircuitData to DAGCircuit.");
 
     // Call the pass

crates/cext/src/transpiler/passes/elide_permutations.rs

@@ -63,7 +63,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_elide_permutations(
 ) -> *mut TranspileLayout {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
-    let dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(_e) => panic!("Internal circuit to DAG conversion failed."),
     };

crates/cext/src/transpiler/passes/gate_direction.rs

@@ -56,7 +56,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_check_gate_direction(
     let circuit = unsafe { const_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
 
-    let dag = DAGCircuit::from_circuit_data(circuit, false, None, None, None, None)
+    let dag = DAGCircuit::from_circuit_data(circuit, false, None, None)
         .expect("Circuit to DAG conversion failed");
 
     check_direction_target(&dag, target).expect("Unexpected error occurred in CheckGateDirection")
@@ -102,7 +102,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_gate_direction(
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
 
-    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None, None, None)
+    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None)
         .expect("Circuit to DAG conversion failed");
 
     fix_direction_target(&mut dag, target).expect("Unexpected error occurred in GateDirection");

crates/cext/src/transpiler/passes/inverse_cancellation.rs

@@ -69,7 +69,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_inverse_cancellation(
 ) {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
-    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(_) => panic!("Internal Circuit -> DAG conversion failed"),
     };

crates/cext/src/transpiler/passes/optimize_1q_sequences.rs

@@ -85,7 +85,7 @@ pub unsafe extern "C" fn qk_transpiler_standalone_optimize_1q_sequences(
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
 
     // Convert the circuit to a DAG.
-    let mut circuit_as_dag = DAGCircuit::from_circuit_data(circuit, false, None, None, None, None)
+    let mut circuit_as_dag = DAGCircuit::from_circuit_data(circuit, false, None, None)
         .expect("Error while converting the circuit to a dag.");
 
     // Run the pass

crates/cext/src/transpiler/passes/remove_diagonal_gates_before_measure.rs

@@ -45,7 +45,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_remove_diagonal_gates_bef
 ) {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
-    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None, None, None)
+    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None)
         .expect("Circuit to DAG conversion failed");
     run_remove_diagonal_before_measure(&mut dag);
     let result = dag_to_circuit(&dag, false).expect("DAG to Circuit conversion failed");

crates/cext/src/transpiler/passes/remove_identity_equiv.rs

@@ -87,7 +87,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_remove_identity_equivalen
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
-    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(e) => panic!("{}", e),
     };

crates/cext/src/transpiler/passes/sabre_layout.rs

@@ -113,7 +113,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_sabre_layout(
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
     let options = unsafe { const_ptr_as_ref(options) };
-    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None, None, None)
+    let mut dag = DAGCircuit::from_circuit_data(circuit, false, None, None)
         .unwrap_or_else(|_| panic!("Internal circuit to DAG conversion failed."));
     let heuristic = heuristic::Heuristic::new(
         Some(heuristic::BasicHeuristic::new(
@@ -145,7 +145,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_sabre_layout(
         .unwrap_or_else(|_| panic!("Internal DAG to circuit conversion failed"));
     let num_input_qubits = circuit.num_qubits() as u32;
     *circuit = out_circuit;
-    let out_permutation = (0..result.num_qubits() as u32)
+    let out_permutation = (0..result.qubits().len() as u32)
         .map(|ref q| {
             Qubit(
                 final_layout

crates/cext/src/transpiler/passes/split_2q_unitaries.rs

@@ -56,7 +56,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_split_2q_unitaries(
 ) -> *mut TranspileLayout {
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
-    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(_e) => panic!("Internal circuit -> DAG conversion failed."),
     };

crates/cext/src/transpiler/passes/unitary_synthesis.rs

@@ -75,7 +75,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_unitary_synthesis(
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { mut_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
-    let mut dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(e) => panic!("{}", e),
     };
@@ -84,9 +84,9 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_unitary_synthesis(
     } else {
         Some(approximation_degree)
     };
-    let qubit_indices = (0..dag.num_qubits()).collect();
+    let qubit_indices = (0..dag.qubits().len()).collect();
     let out_dag = match run_unitary_synthesis(
-        &mut dag,
+        &dag,
         qubit_indices,
         min_qubits,
         Some(target),

crates/cext/src/transpiler/passes/vf2.rs

@@ -333,7 +333,7 @@ pub unsafe extern "C" fn qk_transpiler_pass_standalone_vf2_layout(
     // SAFETY: Per documentation, the pointer is non-null and aligned.
     let circuit = unsafe { const_ptr_as_ref(circuit) };
     let target = unsafe { const_ptr_as_ref(target) };
-    let dag = match DAGCircuit::from_circuit_data(circuit, false, None, None, None, None) {
+    let dag = match DAGCircuit::from_circuit_data(circuit, false, None, None) {
         Ok(dag) => dag,
         Err(e) => panic!("{}", e),
     };

crates/circuit/src/converters.rs

@@ -19,7 +19,7 @@ use pyo3::prelude::*;
 use crate::bit::{ShareableClbit, ShareableQubit};
 use crate::circuit_data::{CircuitData, CircuitVar};
 use crate::dag_circuit::DAGIdentifierInfo;
-use crate::dag_circuit::{DAGCircuit, NodeType};
+use crate::dag_circuit::{DAGCircuit, NodeType, PyDAGCircuit};
 use crate::operations::{OperationRef, PythonOperation};
 use crate::packed_instruction::PackedInstruction;
 
@@ -30,6 +30,8 @@ pub struct QuantumCircuitData<'py> {
     pub data: CircuitData,
     pub name: Option<String>,
     pub metadata: Option<Bound<'py, PyAny>>,
+    pub unit: String,
+    pub duration: Option<Bound<'py, PyAny>>,
 }
 
 impl<'a, 'py> FromPyObject<'a, 'py> for QuantumCircuitData<'py> {
@@ -43,6 +45,8 @@ impl<'a, 'py> FromPyObject<'a, 'py> for QuantumCircuitData<'py> {
             data: data_borrowed,
             name: ob.getattr(intern!(py, "name"))?.extract()?,
             metadata: ob.getattr(intern!(py, "metadata")).ok(),
+            unit: ob.getattr(intern!(py, "_unit"))?.extract()?,
+            duration: ob.getattr(intern!(py, "_duration")).ok(),
         })
     }
 }
@@ -53,11 +57,26 @@ pub fn circuit_to_dag(
     copy_operations: bool,
     qubit_order: Option<Vec<ShareableQubit>>,
     clbit_order: Option<Vec<ShareableClbit>>,
-) -> PyResult<DAGCircuit> {
-    DAGCircuit::from_circuit(quantum_circuit, copy_operations, qubit_order, clbit_order)
+) -> PyResult<PyDAGCircuit> {
+    Ok(PyDAGCircuit {
+        name: quantum_circuit.name,
+        metadata: quantum_circuit.metadata.map(|x| x.unbind()),
+        dag_circuit: DAGCircuit::from_circuit_data(
+            &quantum_circuit.data,
+            copy_operations,
+            qubit_order,
+            clbit_order,
+        )?,
+        unit: quantum_circuit.unit,
+        duration: quantum_circuit.duration.map(|x| x.unbind()),
+    })
+}
+
+#[pyfunction(name="dag_to_circuit", signature = (dag, copy_operations = true))]
+pub fn py_dag_to_circuit(dag: &PyDAGCircuit, copy_operations: bool) -> PyResult<CircuitData> {
+    dag_to_circuit(&dag.dag_circuit, copy_operations)
 }
 
-#[pyfunction(signature = (dag, copy_operations = true))]
 pub fn dag_to_circuit(dag: &DAGCircuit, copy_operations: bool) -> PyResult<CircuitData> {
     CircuitData::from_packed_instructions(
         dag.qubits().clone(),
@@ -102,7 +121,7 @@ pub fn dag_to_circuit(dag: &DAGCircuit, copy_operations: bool) -> PyResult<Circu
                 Ok(instr.clone())
             }
         }),
-        dag.get_global_phase(),
+        dag.global_phase().clone(),
         dag.identifiers() // Map and pass DAGCircuit variables and stretches to CircuitData style
             .map(|identifier| match identifier {
                 DAGIdentifierInfo::Stretch(dag_stretch_info) => CircuitVar::Stretch(
@@ -124,6 +143,6 @@ pub fn dag_to_circuit(dag: &DAGCircuit, copy_operations: bool) -> PyResult<Circu
 
 pub fn converters(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(circuit_to_dag, m)?)?;
-    m.add_function(wrap_pyfunction!(dag_to_circuit, m)?)?;
+    m.add_function(wrap_pyfunction!(py_dag_to_circuit, m)?)?;
     Ok(())
 }