qiskit 1.3.3__cp39-abi3-win_amd64.whl → 1.4.1__cp39-abi3-win_amd64.whl

qiskit/transpiler/preset_passmanagers/common.py

@@ -14,6 +14,7 @@
 """Common preset passmanager generators."""
 
 import collections
+import warnings
 from typing import Optional
 
 from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
@@ -53,7 +54,7 @@ from qiskit.transpiler.passes.layout.vf2_post_layout import VF2PostLayoutStopRea
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.layout import Layout
 from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
-
+from qiskit.utils.deprecation import deprecate_arg
 
 _ControlFlowState = collections.namedtuple("_ControlFlowState", ("working", "not_working"))
 
@@ -275,6 +276,16 @@ def _apply_post_layout_condition(property_set):
     )
 
 
+@deprecate_arg(
+    name="backend_properties",
+    since="1.4",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The BackendProperties data structure has been deprecated and will be "
+    "removed in Qiskit 2.0. The required `target` input argument should be used "
+    "instead. You can use Target.from_configuration() to build the target from the properties "
+    "object, but in 2.0 you will need to generate a target directly.",
+)
 def generate_routing_passmanager(
     routing_pass,
     target,
@@ -352,20 +363,33 @@ def generate_routing_passmanager(
 
     is_vf2_fully_bounded = vf2_call_limit and vf2_max_trials
     if (target is not None or backend_properties is not None) and is_vf2_fully_bounded:
-        routing.append(
-            ConditionalController(
-                VF2PostLayout(
-                    target,
-                    coupling_map,
-                    backend_properties,
-                    seed_transpiler,
-                    call_limit=vf2_call_limit,
-                    max_trials=vf2_max_trials,
-                    strict_direction=False,
-                ),
-                condition=_run_post_layout_condition,
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=".*argument ``properties`` is deprecated as of Qiskit 1.4",
+                module="qiskit",
+            )
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=".*argument ``coupling_map`` is deprecated as of Qiskit 1.4",
+                module="qiskit",
+            )
+            routing.append(
+                ConditionalController(
+                    VF2PostLayout(
+                        target,
+                        coupling_map,
+                        backend_properties,
+                        seed_transpiler,
+                        call_limit=vf2_call_limit,
+                        max_trials=vf2_max_trials,
+                        strict_direction=False,
+                    ),
+                    condition=_run_post_layout_condition,
+                )
             )
-        )
         routing.append(ConditionalController(ApplyLayout(), condition=_apply_post_layout_condition))
 
     def filter_fn(node):
@@ -409,6 +433,16 @@ def generate_pre_op_passmanager(target=None, coupling_map=None, remove_reset_in_
     return pre_opt
 
 
+@deprecate_arg(
+    name="backend_properties",
+    since="1.4",
+    package_name="Qiskit",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="The BackendProperties data structure has been deprecated and will be "
+    "removed in Qiskit 2.0. The required `target` input argument should be used "
+    "instead. You can use Target.from_configuration() to build the target from the properties "
+    "object, but in 2.0 you will need to generate a target directly.",
+)
 def generate_translation_passmanager(
     target,
     basis_gates=None,
@@ -455,76 +489,92 @@ def generate_translation_passmanager(
         TranspilerError: If the ``method`` kwarg is not a valid value
     """
     if method == "translator":
-        unroll = [
-            # Use unitary synthesis for basis aware decomposition of
-            # UnitaryGates before custom unrolling
-            UnitarySynthesis(
-                basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                equivalence_library=sel,
-                basis_gates=basis_gates,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-            BasisTranslator(sel, basis_gates, target),
-        ]
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
+                module="qiskit",
+            )
+            unroll = [
+                # Use unitary synthesis for basis aware decomposition of
+                # UnitaryGates before custom unrolling
+                UnitarySynthesis(
+                    basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    equivalence_library=sel,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+                BasisTranslator(sel, basis_gates, target),
+            ]
     elif method == "synthesis":
-        unroll = [
-            # # Use unitary synthesis for basis aware decomposition of
-            # UnitaryGates > 2q before collection
-            UnitarySynthesis(
-                basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                min_qubits=3,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                basis_gates=basis_gates,
-                min_qubits=3,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-            Unroll3qOrMore(target=target, basis_gates=basis_gates),
-            Collect2qBlocks(),
-            Collect1qRuns(),
-            ConsolidateBlocks(
-                basis_gates=basis_gates, target=target, approximation_degree=approximation_degree
-            ),
-            UnitarySynthesis(
-                basis_gates=basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                basis_gates=basis_gates,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-        ]
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
+                module="qiskit",
+            )
+            unroll = [
+                # Use unitary synthesis for basis aware decomposition of
+                # UnitaryGates > 2q before collection
+                UnitarySynthesis(
+                    basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    min_qubits=3,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    min_qubits=3,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+                Unroll3qOrMore(target=target, basis_gates=basis_gates),
+                Collect2qBlocks(),
+                Collect1qRuns(),
+                ConsolidateBlocks(
+                    basis_gates=basis_gates,
+                    target=target,
+                    approximation_degree=approximation_degree,
+                ),
+                UnitarySynthesis(
+                    basis_gates=basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+            ]
     else:
         raise TranspilerError(f"Invalid translation method {method}.")
     return PassManager(unroll)

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -344,13 +344,34 @@ def generate_preset_pass_manager(
             # preserve the former behavior of transpile.
             backend_properties = _parse_backend_properties(backend_properties, backend)
             with warnings.catch_warnings():
-                # TODO: inst_map will be removed in 2.0
+                # TODO: inst_map and backend_properties will be removed in 2.0
                 warnings.filterwarnings(
                     "ignore",
                     category=DeprecationWarning,
                     message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
                     module="qiskit",
                 )
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=".* ``backend_properties`` is deprecated as of Qiskit 1.4",
+                    module="qiskit",
+                )
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=".*``qiskit.providers.exceptions.BackendPropertyError``",
+                )
+                # TODO: This is a temporary usage of deprecated backend_properties in
+                #   Target.from_configuration. Probably the logic needs to be restructured
+                #   in a more target-centric transpiler
+                #   https://github.com/Qiskit/qiskit/issues/9256
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=r".+qiskit\.transpiler\.target\.Target\.from_configuration.+",
+                    module="qiskit",
+                )
                 # Build target from constraints.
                 target = Target.from_configuration(
                     basis_gates=basis_gates,
@@ -403,7 +424,6 @@ def generate_preset_pass_manager(
     initial_layout = _parse_initial_layout(initial_layout)
     approximation_degree = _parse_approximation_degree(approximation_degree)
     seed_transpiler = _parse_seed_transpiler(seed_transpiler)
-
     pm_options = {
         "target": target,
         "basis_gates": basis_gates,
@@ -428,12 +448,18 @@ def generate_preset_pass_manager(
     }
 
     with warnings.catch_warnings():
-        # inst_map is deprecated in the PassManagerConfig initializer
+        # inst_map and backend_properties are deprecated in the PassManagerConfig initializer
         warnings.filterwarnings(
             "ignore",
             category=DeprecationWarning,
             message=".*argument ``inst_map`` is deprecated as of Qiskit 1.3",
         )
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
+            module="qiskit",
+        )
         if backend is not None:
             pm_options["_skip_target"] = _skip_target
             pm_config = PassManagerConfig.from_backend(backend, **pm_options)

qiskit/transpiler/target.py

@@ -56,9 +56,10 @@ from qiskit.exceptions import QiskitError
 # full target
 from qiskit.providers.backend import QubitProperties  # pylint: disable=unused-import
 from qiskit.providers.models.backendproperties import BackendProperties
-from qiskit.utils import deprecate_func
+from qiskit.utils import deprecate_func, deprecate_arg
 from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency, deprecate_pulse_arg
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -656,28 +657,43 @@ class Target(BaseTarget):
         self,
         operation_name: str,
         qargs: tuple[int, ...],
+        operation_params: list[float] | float | None = None,
     ) -> bool:
-        """Return whether the instruction (operation + qubits) defines a calibration.
+        """Return whether the instruction (operation + operation_params + qubits) defines
+        a calibration.
 
         Args:
             operation_name: The name of the operation for the instruction.
-            qargs: The tuple of qubit indices for the instruction.
+            qargs: The qubit indices for the instruction.
+            operation_params: The parameters for the Instruction. In case
+            of multi-parameter gates, the order of parameters in the tuple
+            must match the order of the gate parameters.
 
         Returns:
             Returns ``True`` if the calibration is supported and ``False`` if it isn't.
         """
-        return self._has_calibration(operation_name, qargs)
+        return self._has_calibration(operation_name, qargs, operation_params)
 
     def _has_calibration(
         self,
         operation_name: str,
         qargs: tuple[int, ...],
+        operation_params: list[float] | float | None = None,
     ) -> bool:
-        qargs = tuple(qargs)
+        if operation_params is not None and not isinstance(operation_params, list):
+            operation_params = [operation_params]
+
         if operation_name not in self._gate_map:
             return False
+
         if qargs not in self._gate_map[operation_name]:
             return False
+
+        if operation_params is not None and not (
+            operation_params == self._gate_name_map[operation_name].params
+        ):
+            return False
+
         return getattr(self._gate_map[operation_name][qargs], "_calibration", None) is not None
 
     @deprecate_pulse_dependency
@@ -686,6 +702,7 @@ class Target(BaseTarget):
         operation_name: str,
         qargs: tuple[int, ...],
         *args: ParameterValueType,
+        operation_params: list[float] | float | None = None,
         **kwargs: ParameterValueType,
     ) -> Schedule | ScheduleBlock:
         """Get calibrated pulse schedule for the instruction.
@@ -695,25 +712,32 @@ class Target(BaseTarget):
 
         Args:
             operation_name: The name of the operation for the instruction.
-            qargs: The tuple of qubit indices for the instruction.
+            qargs: The qubit indices for the instruction.
             args: Parameter values to build schedule if any.
+            operation_params: The parameters for the Instruction. In case
+            of multi-parameter gate, the order of parameters in the tuple
+            must match the order of the gate parameters.
             kwargs: Parameter values with name to build schedule if any.
 
         Returns:
             Calibrated pulse schedule of corresponding instruction.
         """
-        return self._get_calibration(operation_name, qargs, *args, *kwargs)
+        return self._get_calibration(
+            operation_name, qargs, *args, operation_params=operation_params, **kwargs
+        )
 
     def _get_calibration(
         self,
         operation_name: str,
         qargs: tuple[int, ...],
         *args: ParameterValueType,
+        operation_params: list[float] | float | None = None,
         **kwargs: ParameterValueType,
     ) -> Schedule | ScheduleBlock:
-        if not self._has_calibration(operation_name, qargs):
+        if not self._has_calibration(operation_name, qargs, operation_params):
             raise KeyError(
-                f"Calibration of instruction {operation_name} for qubit {qargs} is not defined."
+                f"Calibration of instruction: `{operation_name}`, with params: "
+                f"`{operation_params}` for qubit: {qargs} is not defined."
             )
         cal_entry = getattr(self._gate_map[operation_name][qargs], "_calibration")
         return cal_entry.get_schedule(*args, **kwargs)
@@ -971,6 +995,14 @@ class Target(BaseTarget):
 
     @classmethod
     @deprecate_pulse_arg("inst_map")
+    @deprecate_arg(
+        name="backend_properties",
+        since="1.4",
+        package_name="Qiskit",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="To add instructions with specific properties "
+        "use Target.add_instruction(instruction, properties, name).",
+    )
     def from_configuration(
         cls,
         basis_gates: list[str],

qiskit/visualization/gate_map.py

@@ -13,6 +13,7 @@
 """A module for visualizing device coupling maps"""
 
 import math
+import warnings
 from typing import List
 
 import numpy as np
@@ -21,6 +22,7 @@ from rustworkx.visualization import graphviz_draw
 
 from qiskit.exceptions import QiskitError
 from qiskit.utils import optionals as _optionals
+from qiskit.providers import BackendV2
 from qiskit.providers.exceptions import BackendPropertyError
 from qiskit.transpiler.coupling import CouplingMap
 from .exceptions import VisualizationError
@@ -50,6 +52,12 @@ def plot_gate_map(
 ):
     """Plots the gate map of a device.
 
+    .. deprecated:: 1.4
+        The function ``plot_gate_map`` will stop supporting inputs of type
+        :class:`.BackendV1` in the `backend` parameter in a future release no
+        earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
+        move to :class:`.BackendV2`.
+
     Args:
         backend (Backend): The backend instance that will be used to plot the device
             gate map.
@@ -92,6 +100,15 @@ def plot_gate_map(
 
            plot_gate_map(backend)
     """
+    if not isinstance(backend, BackendV2):
+        warnings.warn(
+            "The function `plot_gate_map` will stop supporting inputs of "
+            f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+            "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+            "should move to `BackendV2`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
     qubit_coordinates_map = {}
 
     qubit_coordinates_map[5] = [[1, 0], [0, 1], [1, 1], [1, 2], [2, 1]]
@@ -1145,6 +1162,12 @@ def plot_circuit_layout(circuit, backend, view="virtual", qubit_coordinates=None
     """Plot the layout of a circuit transpiled for a given
     target backend.
 
+    .. deprecated:: 1.4
+        The function ``plot_circuit_layout`` will stop supporting inputs of type
+        :class:`.BackendV1` in the `backend` parameter in a future release no
+        earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
+        move to :class:`.BackendV2`.
+
     Args:
         circuit (QuantumCircuit): Input quantum circuit.
         backend (Backend): Target backend.
@@ -1187,6 +1210,17 @@ def plot_circuit_layout(circuit, backend, view="virtual", qubit_coordinates=None
             new_circ_lv3 = transpile(ghz, backend=backend, optimization_level=3)
             plot_circuit_layout(new_circ_lv3, backend)
     """
+
+    if not isinstance(backend, BackendV2):
+        warnings.warn(
+            "The function `plot_circuit_layout` will stop supporting inputs of "
+            f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+            "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+            "should move to `BackendV2`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
     if circuit._layout is None:
         raise QiskitError("Circuit has no layout. Perhaps it has not been transpiled.")
 
@@ -1254,6 +1288,12 @@ def plot_circuit_layout(circuit, backend, view="virtual", qubit_coordinates=None
 def plot_error_map(backend, figsize=(15, 12), show_title=True, qubit_coordinates=None):
     """Plots the error map of a given backend.
 
+    .. deprecated:: 1.4
+        The function ``plot_error_map`` will stop supporting inputs of type
+        :class:`.BackendV1` in the `backend` parameter in a future release no
+        earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
+        move to :class:`.BackendV2`.
+
     Args:
         backend (Backend): Given backend.
         figsize (tuple): Figure size in inches.
@@ -1282,6 +1322,16 @@ def plot_error_map(backend, figsize=(15, 12), show_title=True, qubit_coordinates
             backend = GenericBackendV2(num_qubits=5)
             plot_error_map(backend)
     """
+    if not isinstance(backend, BackendV2):
+        warnings.warn(
+            "The function `plot_error_map` will stop supporting inputs of "
+            f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+            "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+            "should move to `BackendV2`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
     import matplotlib
     import matplotlib.pyplot as plt
     from matplotlib import gridspec, ticker

qiskit/visualization/pulse_v2/interface.py

@@ -27,12 +27,10 @@ from qiskit.pulse.channels import Channel
 from qiskit.visualization.exceptions import VisualizationError
 from qiskit.visualization.pulse_v2 import core, device_info, stylesheet, types
 from qiskit.exceptions import MissingOptionalLibraryError
-from qiskit.utils import deprecate_arg
 from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 @deprecate_pulse_dependency(moving_to_dynamics=True)
-@deprecate_arg("show_barrier", new_alias="plot_barrier", since="1.1.0", pending=True)
 def draw(
     program: Union[Waveform, SymbolicPulse, Schedule, ScheduleBlock],
     style: Optional[Dict[str, Any]] = None,

qiskit/visualization/timeline/core.py

@@ -142,6 +142,15 @@ class DrawerCanvas:
     def load_program(self, program: circuit.QuantumCircuit, target: Target | None = None):
         """Load quantum circuit and create drawing..
 
+        .. deprecated:: 1.3
+           Visualization of unscheduled circuits with the timeline drawer has been
+           deprecated in Qiskit 1.3.
+           This circuit should be transpiled with a scheduler, despite having instructions
+           with explicit durations.
+
+        .. deprecated:: 1.3
+           Targets with duration-less operations are going to error in Qiskit 2.0.
+
         Args:
             program: Scheduled circuit object to draw.
             target: The target the circuit is scheduled for. This contains backend information

qiskit/visualization/timeline/interface.py

@@ -30,8 +30,8 @@ from qiskit.visualization.timeline import types, core, stylesheet
 from qiskit.utils import deprecate_arg
 
 
-@deprecate_arg("show_idle", new_alias="idle_wires", since="1.1.0", pending=True)
-@deprecate_arg("show_barriers", new_alias="plot_barriers", since="1.1.0", pending=True)
+@deprecate_arg("show_idle", new_alias="idle_wires", since="1.4")
+@deprecate_arg("show_barriers", new_alias="plot_barriers", since="1.4")
 def draw(
     program: circuit.QuantumCircuit,
     style: Optional[Dict[str, Any]] = None,
@@ -52,6 +52,10 @@ def draw(
 ):
     r"""Generate visualization data for scheduled circuit programs.
 
+    .. deprecated:: 1.3
+       The ``target`` parameter needs to be specified in Qiskit 2.0 in order to get the
+       instruction durations.
+
     Args:
         program: Program to visualize. This program should be a `QuantumCircuit` which is
             transpiled with a scheduling_method, thus containing gate time information.
@@ -372,7 +376,7 @@ def draw(
         warnings.warn(
             "Target is not specified. In Qiskit 2.0.0 this will be required to get the duration of "
             "instructions.",
-            PendingDeprecationWarning,
+            DeprecationWarning,
             stacklevel=2,
         )
 

{qiskit-1.3.3.dist-info → qiskit-1.4.1.dist-info}/METADATA

@@ -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