Do not raise deprecation warnings for internal uses of dag.duration and dag.unit (backport Qiskit#14133) (Qiskit#14147)

* Do not raise deprecation warnings for internal uses of dag.duration and dag.unit (Qiskit#14133)

* Filter Rust deprecation warning when calling dag.duration/dag.unit internally

Filter Rust deprecation warning when calling dag.duration/dag.unit internally

* Apply Matt's suggestions:

* Refactor access patterns: add dag._duration and dag._unit
* Refactor internal uses of dag.duration and dag.unit to rely on internal methods
* Remove blanket warning filters from unit test config

On top of these:

* Extend deprecation warnings to dag.duration and dag.unit setters (previously only in getters)
* Clean up unit test config from old filters

* Change stacklevel

* Fix circuit_to_dag

* Handle failing tests

* _DAGDependencyV2 is private and not a DAGCircuit, so don't use internal attributes

* Reduce duplication in getters and setters

(cherry picked from commit d0aa100)

# Conflicts:
#	crates/circuit/src/dag_circuit.rs
#	qiskit/transpiler/passes/scheduling/padding/base_padding.py
#	test/python/circuit/test_scheduled_circuit.py
#	test/python/compiler/test_transpiler.py
#	test/utils/base.py

* Fix merge conflicts

* Address failing tests

* More fixes

* More fixes

* Last try

---------

Co-authored-by: Elena Peña Tapia <57907331+ElePT@users.noreply.github.com>
Co-authored-by: Elena Peña Tapia <epenatap@gmail.com>

Author: mergify[bot]

crates/circuit/src/dag_circuit.rs

@@ -208,10 +208,8 @@ pub struct DAGCircuit {
     /// Global phase.
     global_phase: Param,
     /// Duration.
-    #[pyo3(set)]
     duration: Option<PyObject>,
     /// Unit of duration.
-    #[pyo3(set)]
     unit: String,
 
     // Note: these are tracked separately from `qubits` and `clbits`
@@ -415,11 +413,11 @@ impl DAGCircuit {
         })
     }
 
-    /// The total duration of the circuit, set by a scheduling transpiler pass. Its unit is
+    /// Returns the total duration of the circuit, set by a scheduling transpiler pass. Its unit is
     /// specified by :attr:`.unit`
     ///
-    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 2.0.0
-    #[getter]
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[getter("duration")]
     fn get_duration(&self, py: Python) -> PyResult<Option<Py<PyAny>>> {
         imports::WARNINGS_WARN.get_bound(py).call1((
             intern!(
@@ -430,12 +428,49 @@ impl DAGCircuit {
                 )
             ),
             py.get_type_bound::<PyDeprecationWarning>(),
-            2,
+            1,
         ))?;
+        self.get_internal_duration(py)
+    }
+
+    /// Returns the total duration of the circuit for internal use (no deprecation warning).
+    ///
+    /// To be removed with get_duration.
+    #[getter("_duration")]
+    fn get_internal_duration(&self, py: Python) -> PyResult<Option<Py<PyAny>>> {
         Ok(self.duration.as_ref().map(|x| x.clone_ref(py)))
     }
 
-    /// The unit that duration is specified in.
+    /// Sets the total duration of the circuit, set by a scheduling transpiler pass. Its unit is
+    /// specified by :attr:`.unit`
+    ///
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[setter("duration")]
+    fn set_duration(&mut self, py: Python, duration: Option<PyObject>) -> PyResult<()> {
+        imports::WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The property ``qiskit.dagcircuit.dagcircuit.DAGCircuit.duration`` is ",
+                    "deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 3.0.0.",
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        self.set_internal_duration(duration);
+        Ok(())
+    }
+
+    /// Sets the total duration of the circuit for internal use (no deprecation warning).
+    ///
+    /// To be removed with set_duration.
+    #[setter("_duration")]
+    fn set_internal_duration(&mut self, duration: Option<PyObject>) {
+        self.duration = duration
+    }
+
+    /// Returns the unit that duration is specified in.
     ///
     /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 2.0.0
     #[getter]
@@ -449,11 +484,47 @@ impl DAGCircuit {
                 )
             ),
             py.get_type_bound::<PyDeprecationWarning>(),
-            2,
+            1,
         ))?;
+        self.get_internal_unit()
+    }
+
+    /// Returns the unit that duration is specified in for internal use (no deprecation warning).
+    ///
+    /// To be removed with get_unit.
+    #[getter("_unit")]
+    fn get_internal_unit(&self) -> PyResult<String> {
         Ok(self.unit.clone())
     }
 
+    /// Sets the unit that duration is specified in.
+    ///
+    /// DEPRECATED since Qiskit 1.3.0 and will be removed in Qiskit 3.0.0
+    #[setter("unit")]
+    fn set_unit(&mut self, py: Python, unit: String) -> PyResult<()> {
+        imports::WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The property ``qiskit.dagcircuit.dagcircuit.DAGCircuit.unit`` is ",
+                    "deprecated as of Qiskit 1.3.0. It will be removed in Qiskit 3.0.0.",
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        self.set_internal_unit(unit);
+        Ok(())
+    }
+
+    /// Sets the unit that duration is specified in for internal use (no deprecation warning).
+    ///
+    /// To be removed with set_unit.
+    #[setter("_unit")]
+    fn set_internal_unit(&mut self, unit: String) {
+        self.unit = unit
+    }
+
     #[getter]
     fn input_map(&self, py: Python) -> PyResult<Py<PyDict>> {
         let out_dict = PyDict::new_bound(py);

qiskit/circuit/duration.py

@@ -65,29 +65,29 @@ def convert_durations_to_dt(qc: QuantumCircuit, dt_in_sec: float, inplace=True):
 
     for instruction in circ.data:
         operation = instruction.operation
-        if operation.unit == "dt" or operation.duration is None:
+        if operation._unit == "dt" or operation._duration is None:
             continue
 
-        if not operation.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{operation.unit}'")
+        if not operation._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{operation._unit}'")
 
-        duration = operation.duration
-        if operation.unit != "s":
-            duration = apply_prefix(duration, operation.unit)
+        duration = operation._duration
+        if operation._unit != "s":
+            duration = apply_prefix(duration, operation._unit)
 
-        operation.duration = duration_in_dt(duration, dt_in_sec)
-        operation.unit = "dt"
+        operation._duration = duration_in_dt(duration, dt_in_sec)
+        operation._unit = "dt"
 
-    if circ.duration is not None and circ.unit != "dt":
-        if not circ.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{circ.unit}'")
+    if circ._duration is not None and circ._unit != "dt":
+        if not circ._unit.endswith("s"):
+            raise CircuitError(f"Invalid time unit: '{circ._unit}'")
 
-        duration = circ.duration
-        if circ.unit != "s":
-            duration = apply_prefix(duration, circ.unit)
+        duration = circ._duration
+        if circ._unit != "s":
+            duration = apply_prefix(duration, circ._unit)
 
-        circ.duration = duration_in_dt(duration, dt_in_sec)
-        circ.unit = "dt"
+        circ._duration = duration_in_dt(duration, dt_in_sec)
+        circ._unit = "dt"
 
     if not inplace:
         return circ

qiskit/circuit/quantumcircuit.py

@@ -1546,8 +1546,8 @@ def reverse_ops(self) -> "QuantumCircuit":
         for instruction in reversed(self.data):
             reverse_circ._append(instruction.replace(operation=instruction.operation.reverse_ops()))
 
-        reverse_circ.duration = self.duration
-        reverse_circ.unit = self.unit
+        reverse_circ._duration = self._duration
+        reverse_circ._unit = self._unit
         return reverse_circ
 
     def reverse_bits(self) -> "QuantumCircuit":
@@ -2620,8 +2620,8 @@ def _append(self, instruction, qargs=(), cargs=(), *, _standard_gate: bool = Fal
         """
         if _standard_gate:
             self._data.append(instruction)
-            self.duration = None
-            self.unit = "dt"
+            self._duration = None
+            self._unit = "dt"
             return instruction
 
         old_style = not isinstance(instruction, CircuitInstruction)
@@ -2643,8 +2643,8 @@ def _append(self, instruction, qargs=(), cargs=(), *, _standard_gate: bool = Fal
             self._data.append_manual_params(instruction, params)
 
         # Invalidate whole circuit duration if an instruction is added
-        self.duration = None
-        self.unit = "dt"
+        self._duration = None
+        self._unit = "dt"
         return instruction.operation if old_style else instruction
 
     @typing.overload
@@ -6584,7 +6584,7 @@ def qubit_start_time(self, *qubits: Union[Qubit, int]) -> float:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6626,7 +6626,7 @@ def qubit_stop_time(self, *qubits: Union[Qubit, int]) -> float:
         Raises:
             CircuitError: if ``self`` is a not-yet scheduled circuit.
         """
-        if self.duration is None:
+        if self._duration is None:
             # circuit has only delays, this is kind of scheduled
             for instruction in self._data:
                 if not isinstance(instruction.operation, Delay):
@@ -6637,7 +6637,7 @@ def qubit_stop_time(self, *qubits: Union[Qubit, int]) -> float:
 
         qubits = [self.qubits[q] if isinstance(q, int) else q for q in qubits]
 
-        stops = {q: self.duration for q in qubits}
+        stops = {q: self._duration for q in qubits}
         dones = {q: False for q in qubits}
         for instruction in reversed(self._data):
             for q in qubits:

qiskit/converters/circuit_to_dag.py

@@ -73,6 +73,6 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
-    dagcircuit.duration = circuit._duration
-    dagcircuit.unit = circuit._unit
+    dagcircuit._duration = circuit._duration
+    dagcircuit._unit = circuit._unit
     return dagcircuit

qiskit/converters/dag_to_circuit.py

@@ -74,7 +74,6 @@ def dag_to_circuit(dag, copy_operations=True):
     circuit._calibrations_prop = dag._calibrations_prop
 
     circuit._data = circuit_data
-
-    circuit._duration = dag.duration
-    circuit._unit = dag.unit
+    circuit._duration = dag._duration
+    circuit._unit = dag._unit
     return circuit

qiskit/dagcircuit/dagdependency_v2.py

@@ -525,15 +525,16 @@ def copy_empty_like(self):
         target_dag = _DAGDependencyV2()
         target_dag.name = self.name
         target_dag._global_phase = self._global_phase
-        target_dag.duration = self.duration
-        target_dag.unit = self.unit
         target_dag.metadata = self.metadata
         target_dag._key_cache = self._key_cache
         target_dag.comm_checker = self.comm_checker
 
         target_dag.add_qubits(self.qubits)
         target_dag.add_clbits(self.clbits)
 
+        target_dag.duration = self.duration
+        target_dag.unit = self.unit
+
         for qreg in self.qregs.values():
             target_dag.add_qreg(qreg)
         for creg in self.cregs.values():

qiskit/transpiler/passes/scheduling/alap.py

@@ -147,7 +147,7 @@ def run(self, dag):
         new_dag._calibrations_prop = dag._calibrations_prop
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
 
         return new_dag

qiskit/transpiler/passes/scheduling/alignments/align_measures.py

@@ -129,7 +129,7 @@ def run(self, dag: DAGCircuit):
             return dag
 
         # if circuit is not yet scheduled, schedule with ALAP method
-        if dag.duration is None:
+        if dag._duration is None:
             raise TranspilerError(
                 f"This circuit {dag.name} may involve a delay instruction violating the "
                 "pulse controller alignment. To adjust instructions to "
@@ -201,8 +201,8 @@ def pad_with_delays(qubits: Iterable[QubitSpecifier], until, unit) -> None:
         new_dag.metadata = dag.metadata
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
 
         return new_dag
 

qiskit/transpiler/passes/scheduling/asap.py

@@ -170,6 +170,6 @@ def run(self, dag):
         new_dag._calibrations_prop = dag._calibrations_prop
 
         # set circuit duration and unit to indicate it is scheduled
-        new_dag.duration = circuit_duration
-        new_dag.unit = time_unit
+        new_dag._duration = circuit_duration
+        new_dag._unit = time_unit
         return new_dag

qiskit/transpiler/passes/scheduling/dynamical_decoupling.py

@@ -168,7 +168,7 @@ def run(self, dag):
         if len(dag.qregs) != 1 or dag.qregs.get("q", None) is None:
             raise TranspilerError("DD runs on physical circuits only.")
 
-        if dag.duration is None:
+        if dag._duration is None:
             raise TranspilerError("DD runs after circuit is scheduled.")
 
         durations = self._update_inst_durations(dag)