qiskit 1.3.3__tar.gz → 1.4.1__tar.gz

{qiskit-1.3.3 → qiskit-1.4.1}/Cargo.lock

@@ -1150,7 +1150,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-accelerate"
-version = "1.3.3"
+version = "1.4.1"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1182,7 +1182,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-circuit"
-version = "1.3.3"
+version = "1.4.1"
 dependencies = [
  "ahash 0.8.11",
  "approx 0.5.1",
@@ -1202,7 +1202,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-pyext"
-version = "1.3.3"
+version = "1.4.1"
 dependencies = [
  "pyo3",
  "qiskit-accelerate",
@@ -1213,7 +1213,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm2"
-version = "1.3.3"
+version = "1.4.1"
 dependencies = [
  "hashbrown 0.14.5",
  "num-bigint",
@@ -1223,7 +1223,7 @@ dependencies = [
 
 [[package]]
 name = "qiskit-qasm3"
-version = "1.3.3"
+version = "1.4.1"
 dependencies = [
  "ahash 0.8.11",
  "hashbrown 0.14.5",

{qiskit-1.3.3 → qiskit-1.4.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "1.3.3"
+version = "1.4.1"
 edition = "2021"
 rust-version = "1.70"  # Keep in sync with README.md and rust-toolchain.toml.
 license = "Apache-2.0"

{qiskit-1.3.3 → qiskit-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qiskit
-Version: 1.3.3
+Version: 1.4.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0

qiskit-1.4.1/crates/accelerate/src/circuit_duration.rs

@@ -0,0 +1,112 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2025
+//
+// 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.
+
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType, Wire};
+use qiskit_circuit::operations::{Operation, OperationRef, Param};
+
+use crate::nlayout::PhysicalQubit;
+use crate::target_transpiler::Target;
+use crate::QiskitError;
+use rustworkx_core::dag_algo::longest_path;
+use rustworkx_core::petgraph::stable_graph::StableDiGraph;
+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> {
+    let dt = target.dt;
+
+    let get_duration =
+        |edge: <&StableDiGraph<NodeType, Wire> as IntoEdgeReferences>::EdgeRef| -> PyResult<f64> {
+            let node_weight = &dag.dag()[edge.target()];
+            match node_weight {
+                NodeType::Operation(inst) => {
+                    let name = inst.op.name();
+                    let qubits = dag.get_qargs(inst.qubits);
+                    let physical_qubits: Vec<PhysicalQubit> =
+                        qubits.iter().map(|x| PhysicalQubit::new(x.0)).collect();
+
+                    if name == "delay" {
+                        let dur = &inst.params.as_ref().unwrap()[0];
+                        let OperationRef::Instruction(op) = inst.op.view() else {
+                            unreachable!("Invalid type for delay instruction");
+                        };
+                        Python::with_gil(|py| {
+                            let unit: String = op
+                                .instruction
+                                .getattr(py, intern!(py, "unit"))?
+                                .extract(py)?;
+                            if unit == "dt" {
+                                if let Some(dt) = dt {
+                                    match dur {
+                                    Param::Float(val) => Ok(val * dt),
+                                    Param::Obj(val) => {
+                                        let dur_float: f64 = val.extract(py)?;
+                                        Ok(dur_float * dt)
+                                    },
+                                    Param::ParameterExpression(_) => Err(QiskitError::new_err(
+                                        "Circuit contains parameterized delays, can't compute a duration estimate with this circuit"
+                                    )),
+                                }
+                                } else {
+                                    Err(QiskitError::new_err(
+                                        "Circuit contains delays in dt but the target doesn't specify dt"
+                                    ))
+                                }
+                            } else if unit == "s" {
+                                match dur {
+                                    Param::Float(val) => Ok(*val),
+                                    _ => Err(QiskitError::new_err(
+                                        "Invalid type for parameter value for delay in circuit",
+                                    )),
+                                }
+                            } else {
+                                Err(QiskitError::new_err(
+                                    "Circuit contains delays in units other then seconds or dt, the circuit is not scheduled."
+                                ))
+                            }
+                        })
+                    } else if name == "barrier" {
+                        Ok(0.)
+                    } else {
+                        match target.get_duration(name, &physical_qubits) {
+                            Some(dur) => Ok(dur),
+                            None => Err(QiskitError::new_err(format!(
+                                "Duration not found for {} on qubits: {:?}",
+                                name, qubits
+                            ))),
+                        }
+                    }
+                }
+                NodeType::QubitOut(_) | NodeType::ClbitOut(_) => Ok(0.),
+                NodeType::ClbitIn(_) | NodeType::QubitIn(_) => {
+                    Err(QiskitError::new_err("Invalid circuit provided"))
+                }
+                _ => Err(QiskitError::new_err(
+                    "Circuit contains Vars, duration can't be calculated with classical variables",
+                )),
+            }
+        };
+    match longest_path(dag.dag(), get_duration)? {
+        Some((_, weight)) => Ok(weight),
+        None => Err(QiskitError::new_err("Invalid circuit provided")),
+    }
+}
+
+pub fn compute_duration(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(compute_estimated_duration))?;
+    Ok(())
+}

{qiskit-1.3.3 → qiskit-1.4.1}/crates/accelerate/src/lib.rs

@@ -21,6 +21,7 @@ use pyo3::import_exception;
 pub mod barrier_before_final_measurement;
 pub mod basis;
 pub mod check_map;
+pub mod circuit_duration;
 pub mod circuit_library;
 pub mod commutation_analysis;
 pub mod commutation_cancellation;

{qiskit-1.3.3 → qiskit-1.4.1}/crates/accelerate/src/sparse_observable.rs

@@ -2301,7 +2301,7 @@ impl SparseObservable {
     /// Get a :class:`.PauliList` object that represents the measurement basis needed for each term
     /// (in order) in this observable.
     ///
-    /// For example, the projector ``0l+`` will return a Pauli ``ZXY``.  The resulting
+    /// For example, the projector ``0l+`` will return a Pauli ``ZYX``.  The resulting
     /// :class:`.Pauli` is dense, in the sense that explicit identities are stored.  An identity in
     /// the Pauli output does not require a concrete measurement.
     ///

{qiskit-1.3.3 → qiskit-1.4.1}/crates/accelerate/src/target_transpiler/mod.rs

@@ -951,6 +951,17 @@ impl Target {
         })
     }
 
+    /// Get the duration of a given instruction in the target
+    pub fn get_duration(&self, name: &str, qargs: &[PhysicalQubit]) -> Option<f64> {
+        self.gate_map.get(name).and_then(|gate_props| {
+            let qargs_key: Qargs = qargs.iter().cloned().collect();
+            match gate_props.get(Some(&qargs_key)) {
+                Some(props) => props.as_ref().and_then(|inst_props| inst_props.duration),
+                None => None,
+            }
+        })
+    }
+
     /// Get an iterator over the indices of all physical qubits of the target
     pub fn physical_qubits(&self) -> impl ExactSizeIterator<Item = usize> {
         0..self.num_qubits.unwrap_or_default()

{qiskit-1.3.3 → qiskit-1.4.1}/crates/circuit/src/dag_node.rs

@@ -15,7 +15,7 @@ use std::cell::OnceCell;
 use std::hash::Hasher;
 
 use crate::circuit_instruction::{CircuitInstruction, OperationFromPython};
-use crate::imports::QUANTUM_CIRCUIT;
+use crate::imports::{QUANTUM_CIRCUIT, WARNINGS_WARN};
 use crate::operations::{Operation, Param};
 use crate::TupleLikeArg;
 
@@ -24,7 +24,7 @@ use approx::relative_eq;
 use rustworkx_core::petgraph::stable_graph::NodeIndex;
 
 use numpy::IntoPyArray;
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyDeprecationWarning, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyString, PyTuple};
 use pyo3::{intern, IntoPy, PyObject, PyResult, ToPyObject};
@@ -111,7 +111,6 @@ impl DAGNode {
 #[pyclass(module = "qiskit._accelerate.circuit", extends=DAGNode)]
 pub struct DAGOpNode {
     pub instruction: CircuitInstruction,
-    #[pyo3(get)]
     pub sort_key: PyObject,
 }
 
@@ -124,7 +123,7 @@ impl DAGOpNode {
         op: Bound<PyAny>,
         qargs: Option<TupleLikeArg>,
         cargs: Option<TupleLikeArg>,
-        #[allow(unused_variables)] dag: Option<Bound<PyAny>>,
+        dag: Option<Bound<PyAny>>,
     ) -> PyResult<Py<Self>> {
         let py_op = op.extract::<OperationFromPython>()?;
         let qargs = qargs.map_or_else(|| PyTuple::empty_bound(py), |q| q.value);
@@ -139,7 +138,19 @@ impl DAGOpNode {
             #[cfg(feature = "cache_pygates")]
             py_op: op.unbind().into(),
         };
-
+        if dag.is_some() {
+            WARNINGS_WARN.get_bound(py).call1((
+                intern!(
+                    py,
+                    concat!(
+                        "The ``dag`` parameter in DAGNode subclass constructors ",
+                        "is unused and it will be removed in Qiskit 2.0.",
+                    )
+                ),
+                py.get_type_bound::<PyDeprecationWarning>(),
+                2,
+            ))?;
+        }
         Py::new(
             py,
             (
@@ -152,6 +163,25 @@ impl DAGOpNode {
         )
     }
 
+    #[getter]
+    fn sort_key(&self, py: Python) -> PyResult<PyObject> {
+        WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The sort_key attribute of DAGOpNode has been deprecated ",
+                    "and will be removed in the Qiskit 2.0.0 release. ",
+                    "Instead you can create this by looking at the `qargs` and ",
+                    "`cargs` attributes to create an equivalent string for a ",
+                    "given DAGOpNode instance.",
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        Ok(self.sort_key.clone_ref(py))
+    }
+
     fn __hash__(slf: PyRef<'_, Self>) -> PyResult<u64> {
         let super_ = slf.as_ref();
         let mut hasher = AHasher::default();
@@ -462,7 +492,6 @@ impl DAGOpNode {
 pub struct DAGInNode {
     #[pyo3(get)]
     pub wire: PyObject,
-    #[pyo3(get)]
     sort_key: PyObject,
 }
 
@@ -491,6 +520,25 @@ impl DAGInNode {
         ))
     }
 
+    #[getter]
+    fn sort_key(&self, py: Python) -> PyResult<PyObject> {
+        WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The sort_key attribute of DAGInNode has been deprecated ",
+                    "and will be removed in the Qiskit 2.0.0 release. ",
+                    "Instead you can create this by looking at the `wire` ",
+                    "attribute to create an equivalent string for a given ",
+                    "DAGInNode instance."
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        Ok(self.sort_key.clone_ref(py))
+    }
+
     fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
         let state = (slf.as_ref().node.map(|node| node.index()), &slf.sort_key);
         (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)
@@ -535,7 +583,6 @@ impl DAGInNode {
 pub struct DAGOutNode {
     #[pyo3(get)]
     pub wire: PyObject,
-    #[pyo3(get)]
     sort_key: PyObject,
 }
 
@@ -564,6 +611,25 @@ impl DAGOutNode {
         ))
     }
 
+    #[getter]
+    fn sort_key(&self, py: Python) -> PyResult<PyObject> {
+        WARNINGS_WARN.get_bound(py).call1((
+            intern!(
+                py,
+                concat!(
+                    "The sort_key attribute of DAGOutNode has been deprecated ",
+                    "and will be removed in the Qiskit 2.0.0 release. ",
+                    "Instead you can create this by looking at the `wire` ",
+                    "attribute to create an equivalent string for a given ",
+                    "DAGInNode instance."
+                )
+            ),
+            py.get_type_bound::<PyDeprecationWarning>(),
+            1,
+        ))?;
+        Ok(self.sort_key.clone_ref(py))
+    }
+
     fn __reduce__(slf: PyRef<Self>, py: Python) -> PyObject {
         let state = (slf.as_ref().node.map(|node| node.index()), &slf.sort_key);
         (py.get_type_bound::<Self>(), (&slf.wire,), state).into_py(py)

{qiskit-1.3.3 → qiskit-1.4.1}/crates/pyext/src/lib.rs

@@ -31,6 +31,7 @@ fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
     add_submodule(m, ::qiskit_accelerate::barrier_before_final_measurement::barrier_before_final_measurements_mod, "barrier_before_final_measurement")?;
     add_submodule(m, ::qiskit_accelerate::basis::basis, "basis")?;
     add_submodule(m, ::qiskit_accelerate::check_map::check_map_mod, "check_map")?;
+    add_submodule(m, ::qiskit_accelerate::circuit_duration::compute_duration, "circuit_duration")?;
     add_submodule(m, ::qiskit_accelerate::circuit_library::circuit_library, "circuit_library")?;
     add_submodule(m, ::qiskit_accelerate::commutation_analysis::commutation_analysis, "commutation_analysis")?;
     add_submodule(m, ::qiskit_accelerate::commutation_cancellation::commutation_cancellation, "commutation_cancellation")?;

qiskit-1.4.1/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.4.1

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/__init__.py

@@ -110,6 +110,7 @@ sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 sys.modules["qiskit._accelerate.twirling"] = _accelerate.twirling
 sys.modules["qiskit._accelerate.high_level_synthesis"] = _accelerate.high_level_synthesis
 sys.modules["qiskit._accelerate.remove_identity_equiv"] = _accelerate.remove_identity_equiv
+sys.modules["qiskit._accelerate.circuit_duration"] = _accelerate.circuit_duration
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/bit.py

@@ -14,6 +14,7 @@
 Quantum bit and Classical bit objects.
 """
 import copy
+import warnings
 
 from qiskit.circuit.exceptions import CircuitError
 
@@ -57,6 +58,17 @@ class Bit:
             self._hash = hash((self._register, self._index))
             self._repr = f"{self.__class__.__name__}({self._register}, {self._index})"
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Bit' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     def __repr__(self):
         """Return the official string representing the bit."""
         if (self._register, self._index) == (None, None):

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/classicalfunction/__init__.py

@@ -20,6 +20,10 @@ ClassicalFunction compiler (:mod:`qiskit.circuit.classicalfunction`)
 Overview
 ========
 
+.. warning::
+    
+    This module is deprecated as of Qiskit 1.4.0. It will be removed in the Qiskit 2.0 release.
+
 The classical function compiler provides the necessary tools to map a classical
 potentially irreversible functions into quantum circuits.  Below is a simple example of
 how to synthesize a simple boolean function defined using Python into a
@@ -111,7 +115,7 @@ Exceptions
    ClassicalFunctionCompilerTypeError
 
 """
-
+from qiskit.utils.deprecation import deprecate_func
 from .classicalfunction import ClassicalFunction
 from .exceptions import (
     ClassicalFunctionParseError,
@@ -121,6 +125,14 @@ from .exceptions import (
 from .boolean_expression import BooleanExpression
 
 
+@deprecate_func(
+    since="1.4",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+    "bit-flip oracle by applying Hadamard gates on the target "
+    "qubit before and after the instruction, and conditioning."
+    "the instruction on the target qubit.",
+)
 def classical_function(func):
     """
     Parses and type checks the callable ``func`` to compile it into an ``ClassicalFunction``

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/classicalfunction/boolean_expression.py

@@ -15,15 +15,24 @@
 from os.path import basename, isfile
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
 from .classical_element import ClassicalElement
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class BooleanExpression(ClassicalElement):
     """The Boolean Expression gate."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, expression: str, name: str = None, var_order: list = None) -> None:
         """
         Args:

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/classicalfunction/classicalfunction.py

@@ -15,6 +15,7 @@
 import ast
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit, QuantumRegister
 from qiskit.exceptions import QiskitError
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
@@ -23,10 +24,18 @@ from .classical_function_visitor import ClassicalFunctionVisitor
 from .utils import tweedledum2qiskit
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class ClassicalFunction(ClassicalElement):
     """Represent a classical function and its logic network."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, source, name=None):
         """Creates a ``ClassicalFunction`` from Python source code in ``source``.
 

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/classicalfunction/exceptions.py

@@ -10,7 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Exceptions for ClassicalFunction compiler"""
+"""Exceptions for ClassicalFunction compiler
+
+.. warning::
+    
+    This module is deprecated as of qiskit 1.4.0 version. It will be removed in the Qiskit 2.0 release.
+
+"""
 
 from qiskit.exceptions import QiskitError
 

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/instruction.py

@@ -64,14 +64,20 @@ class Instruction(Operation):
     def __init__(self, name, num_qubits, num_clbits, params, duration=None, unit="dt", label=None):
         """Create a new instruction.
 
+        .. deprecated:: 1.3
+           The parameters ``duration`` and ``unit`` are deprecated since
+           Qiskit 1.3, and they will be removed in 2.0 or later.
+           An instruction's duration is defined in a backend's Target object.
+
         Args:
             name (str): instruction name
             num_qubits (int): instruction's qubit width
             num_clbits (int): instruction's clbit width
             params (list[int|float|complex|str|ndarray|list|ParameterExpression]):
                 list of parameters
-            duration (int or float): instruction's duration. it must be integer if ``unit`` is 'dt'
-            unit (str): time unit of duration
+            duration (int|float): (DEPRECATED) instruction's duration. it must be
+                an integer if ``unit`` is ``'dt'``
+            unit (str): (DEPRECATED) time unit of duration
             label (str or None): An optional label for identifying the instruction.
 
         Raises:

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/library/generalized_gates/mcmt.py

@@ -49,7 +49,7 @@ class MCMT(QuantumCircuit):
     :class:`~qiskit.circuit.library.MCMTVChain`.
     """
 
-    @deprecate_func(since="1.3", additional_msg="Use MCMTGate instead.", pending=True)
+    @deprecate_func(since="1.4", additional_msg="Use MCMTGate instead.")
     def __init__(
         self,
         gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
@@ -76,7 +76,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a callable to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "gate instance or the gate name instead, e.g. pass 'h' instead of QuantumCircuit.h.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.__name__
@@ -84,7 +84,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a QuantumCircuit is pending deprecation since Qiskit 1.3. Pass a gate "
                 "or turn the circuit into a gate using the ``to_gate`` method, instead.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.to_gate()
@@ -158,9 +158,8 @@ class MCMTVChain(MCMT):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="1.4",
         additional_msg="Use MCMTGate with the V-chain synthesis plugin instead.",
-        pending=True,
     )
     def __init__(
         self,
@@ -277,7 +276,7 @@ class MCMTGate(ControlledGate):
             warnings.warn(
                 "Passing a controlled gate to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "single-qubit gate instance or the gate name instead, e.g. pass 'h' instead of 'ch'.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             base_gate = gate.base_gate

{qiskit-1.3.3 → qiskit-1.4.1}/qiskit/circuit/library/phase_oracle.py

@@ -63,31 +63,38 @@ class PhaseOracle(QuantumCircuit):
             var_order(list): A list with the order in which variables will be created.
                (default: by appearance)
         """
-        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
-        from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
+        # ignore deprecation warning for BooleanExpression; implementation is changing in 2.0
+        import warnings
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+            from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
 
-        if not isinstance(expression, ClassicalElement):
-            expression = BooleanExpression(expression, var_order=var_order)
+            if not isinstance(expression, ClassicalElement):
+                expression = BooleanExpression(expression, var_order=var_order)
 
-        self.boolean_expression = expression
+            self.boolean_expression = expression
 
-        if synthesizer is None:
+            if synthesizer is None:
 
-            def synthesizer(boolean_expression):
-                from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-                from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
+                def synthesizer(boolean_expression):
+                    from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
+                    from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
 
-                truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
-                    output_bit=0
-                )
-                tweedledum_circuit = pkrm_synth(truth_table, {"pkrm_synth": {"phase_esop": True}})
-                return tweedledum2qiskit(tweedledum_circuit)
+                    truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
+                        output_bit=0
+                    )
+                    tweedledum_circuit = pkrm_synth(
+                        truth_table, {"pkrm_synth": {"phase_esop": True}}
+                    )
+                    return tweedledum2qiskit(tweedledum_circuit)
 
-        oracle = expression.synth(synthesizer=synthesizer)
+            oracle = expression.synth(synthesizer=synthesizer)
 
-        super().__init__(oracle.num_qubits, name="Phase Oracle")
+            super().__init__(oracle.num_qubits, name="Phase Oracle")
 
-        self.compose(oracle, inplace=True, copy=False)
+            self.compose(oracle, inplace=True, copy=False)
 
     def evaluate_bitstring(self, bitstring: str) -> bool:
         """Evaluate the oracle on a bitstring.