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

* 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)

Co-authored-by: Elena Peña Tapia <[email protected]>

Author: mergify[bot]

crates/circuit/src/dag_circuit.rs

@@ -211,10 +211,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`
@@ -500,11 +498,11 @@ impl DAGCircuit {
         self.clbit_locations.cached(py)
     }
 
-    /// 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 3.0.0
-    #[getter]
+    #[getter("duration")]
     fn get_duration(&self, py: Python) -> PyResult<Option<Py<PyAny>>> {
         imports::WARNINGS_WARN.get_bound(py).call1((
             intern!(
@@ -515,12 +513,49 @@ impl DAGCircuit {
                 )
             ),
             py.get_type::<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::<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 3.0.0
     #[getter]
@@ -534,11 +569,47 @@ impl DAGCircuit {
                 )
             ),
             py.get_type::<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::<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(py);

qiskit/circuit/quantumcircuit.py

@@ -1420,8 +1420,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":
@@ -2559,8 +2559,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)
@@ -2582,8 +2582,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
@@ -6951,7 +6951,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):
@@ -6993,7 +6993,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):
@@ -7004,7 +7004,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

@@ -75,6 +75,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.add_stretch(stretch)
     circuit.metadata = dag.metadata or {}
     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

@@ -447,15 +447,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/padding/base_padding.py

@@ -124,7 +124,7 @@ def run(self, dag: DAGCircuit):
 
         new_dag.name = dag.name
         new_dag.metadata = dag.metadata
-        new_dag.unit = self.property_set["time_unit"]
+        new_dag._unit = self.property_set["time_unit"]
         new_dag.global_phase = dag.global_phase
 
         idle_after = {bit: 0 for bit in dag.qubits}
@@ -186,7 +186,7 @@ def run(self, dag: DAGCircuit):
                     prev_node=prev_node,
                 )
 
-        new_dag.duration = circuit_duration
+        new_dag._duration = circuit_duration
 
         return new_dag
 

qiskit/transpiler/passes/scheduling/padding/dynamical_decoupling.py

@@ -310,22 +310,22 @@ def _pad(
 
         if not self.__is_dd_qubit(dag.qubits.index(qubit)):
             # Target physical qubit is not the target of this DD sequence.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if self._skip_reset_qubits and (
             isinstance(prev_node, DAGInNode) or isinstance(prev_node.op, Reset)
         ):
             # Previous node is the start edge or reset, i.e. qubit is ground state.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         slack = time_interval - np.sum(self._dd_sequence_lengths[qubit])
         sequence_gphase = self._sequence_phase
 
         if slack <= 0:
             # Interval too short.
-            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+            self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
             return
 
         if len(self._dd_sequence) == 1:
@@ -351,7 +351,7 @@ def _pad(
                 sequence_gphase += phase
             else:
                 # Don't do anything if there's no single-qubit gate to absorb the inverse
-                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+                self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)
                 return
 
         def _constrained_length(values):
@@ -387,7 +387,7 @@ def _constrained_length(values):
             if dd_ind < len(taus):
                 tau = taus[dd_ind]
                 if tau > 0:
-                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag.unit), qubit)
+                    self._apply_scheduled_op(dag, idle_after, Delay(tau, dag._unit), qubit)
                     idle_after += tau
             if dd_ind < len(self._dd_sequence):
                 gate = self._dd_sequence[dd_ind]

qiskit/transpiler/passes/scheduling/padding/pad_delay.py

@@ -87,4 +87,4 @@ def _pad(
             return
 
         time_interval = t_end - t_start
-        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag.unit), qubit)
+        self._apply_scheduled_op(dag, t_start, Delay(time_interval, dag._unit), qubit)

qiskit/visualization/timeline/core.py

@@ -260,7 +260,7 @@ def load_program(self, program: circuit.QuantumCircuit, target: Target | None =
                     self.add_data(datum)
 
         # update time range
-        t_end = max(program.duration, self.formatter["margin.minimum_duration"])
+        t_end = max(program._duration, self.formatter["margin.minimum_duration"])
         self.set_time_range(t_start=0, t_end=t_end)
 
     def set_time_range(self, t_start: int, t_end: int):