qiskit 1.1.2__cp38-abi3-macosx_10_9_universal2.whl → 1.2.0__cp38-abi3-macosx_10_9_universal2.whl

qiskit/compiler/transpiler.py

@@ -13,7 +13,6 @@
 # pylint: disable=invalid-sequence-index
 
 """Circuit transpile function"""
-import copy
 import logging
 from time import time
 from typing import List, Union, Dict, Callable, Any, Optional, TypeVar
@@ -21,20 +20,18 @@ import warnings
 
 from qiskit import user_config
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import Qubit
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.providers.backend import Backend
 from qiskit.providers.backend_compat import BackendV2Converter
-from qiskit.providers.models import BackendProperties
+from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.pulse import Schedule, InstructionScheduleMap
 from qiskit.transpiler import Layout, CouplingMap, PropertySet
 from qiskit.transpiler.basepasses import BasePass
 from qiskit.transpiler.exceptions import TranspilerError, CircuitTooWideForTarget
-from qiskit.transpiler.instruction_durations import InstructionDurations, InstructionDurationsType
+from qiskit.transpiler.instruction_durations import InstructionDurationsType
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
-from qiskit.transpiler.timing_constraints import TimingConstraints
-from qiskit.transpiler.target import Target, target_to_backend_properties
+from qiskit.transpiler.target import Target
 
 logger = logging.getLogger(__name__)
 
@@ -318,10 +315,28 @@ def transpile(  # pylint: disable=too-many-return-statements
         optimization_level = config.get("transpile_optimization_level", 1)
 
     if backend is not None and getattr(backend, "version", 0) <= 1:
-        # This is a temporary conversion step to allow for a smoother transition
-        # to a fully target-based transpiler pipeline while maintaining the behavior
-        # of `transpile` with BackendV1 inputs.
-        backend = BackendV2Converter(backend)
+        warnings.warn(
+            "The `transpile` function 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,
+        )
+        with warnings.catch_warnings():
+            # This is a temporary conversion step to allow for a smoother transition
+            # to a fully target-based transpiler pipeline while maintaining the behavior
+            # of `transpile` with BackendV1 inputs.
+            # TODO BackendV1 is deprecated and this path can be
+            #   removed once it gets removed:
+            #   https://github.com/Qiskit/qiskit/pull/12850
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=r".+qiskit\.providers\.backend_compat\.BackendV2Converter.+",
+                module="qiskit",
+            )
+            backend = BackendV2Converter(backend)
 
     if (
         scheduling_method is not None
@@ -335,73 +350,29 @@ def transpile(  # pylint: disable=too-many-return-statements
             UserWarning,
         )
 
-    _skip_target = False
-    _given_inst_map = bool(inst_map)  # check before inst_map is overwritten
-    # If a target is specified, have it override any implicit selections from a backend
-    if target is not None:
-        if coupling_map is None:
-            coupling_map = target.build_coupling_map()
-        if basis_gates is None:
-            basis_gates = list(target.operation_names)
-        if instruction_durations is None:
-            instruction_durations = target.durations()
-        if inst_map is None:
-            inst_map = target.instruction_schedule_map()
-        if dt is None:
-            dt = target.dt
-        if timing_constraints is None:
-            timing_constraints = target.timing_constraints()
-        if backend_properties is None:
-            backend_properties = target_to_backend_properties(target)
-    # If target is not specified and any hardware constraint object is
-    # manually specified, do not use the target from the backend as
-    # it is invalidated by a custom basis gate list, custom coupling map,
-    # custom dt or custom instruction_durations
-    elif (
-        basis_gates is not None  # pylint: disable=too-many-boolean-expressions
-        or coupling_map is not None
-        or dt is not None
-        or instruction_durations is not None
-        or backend_properties is not None
-        or timing_constraints is not None
-    ):
-        _skip_target = True
-    else:
-        target = getattr(backend, "target", None)
-
-    initial_layout = _parse_initial_layout(initial_layout)
-    coupling_map = _parse_coupling_map(coupling_map, backend)
-    approximation_degree = _parse_approximation_degree(approximation_degree)
-
-    output_name = _parse_output_name(output_name, circuits)
-    inst_map = _parse_inst_map(inst_map, backend)
-
-    _check_circuits_coupling_map(circuits, coupling_map, backend)
-
-    timing_constraints = _parse_timing_constraints(backend, timing_constraints)
-    instruction_durations = _parse_instruction_durations(backend, instruction_durations, dt)
-
-    if _given_inst_map and inst_map.has_custom_gate() and target is not None:
-        # Do not mutate backend target
-        target = copy.deepcopy(target)
-        target.update_from_instruction_schedule_map(inst_map)
-
     if not ignore_backend_supplied_default_methods:
         if scheduling_method is None and hasattr(backend, "get_scheduling_stage_plugin"):
             scheduling_method = backend.get_scheduling_stage_plugin()
         if translation_method is None and hasattr(backend, "get_translation_stage_plugin"):
             translation_method = backend.get_translation_stage_plugin()
 
+    output_name = _parse_output_name(output_name, circuits)
+    coupling_map = _parse_coupling_map(coupling_map)
+    _check_circuits_coupling_map(circuits, coupling_map, backend)
+
+    # Edge cases require using the old model (loose constraints) instead of building a target,
+    # but we don't populate the passmanager config with loose constraints unless it's one of
+    # the known edge cases to control the execution path.
     pm = generate_preset_pass_manager(
         optimization_level,
-        backend=backend,
         target=target,
+        backend=backend,
         basis_gates=basis_gates,
-        inst_map=inst_map,
         coupling_map=coupling_map,
         instruction_durations=instruction_durations,
         backend_properties=backend_properties,
         timing_constraints=timing_constraints,
+        inst_map=inst_map,
         initial_layout=initial_layout,
         layout_method=layout_method,
         routing_method=routing_method,
@@ -414,14 +385,15 @@ def transpile(  # pylint: disable=too-many-return-statements
         hls_config=hls_config,
         init_method=init_method,
         optimization_method=optimization_method,
-        _skip_target=_skip_target,
+        dt=dt,
     )
+
     out_circuits = pm.run(circuits, callback=callback, num_processes=num_processes)
+
     for name, circ in zip(output_name, out_circuits):
         circ.name = name
     end_time = time()
     _log_transpile_time(start_time, end_time)
-
     if arg_circuits_list:
         return out_circuits
     else:
@@ -447,72 +419,24 @@ def _check_circuits_coupling_map(circuits, cmap, backend):
 
 
 def _log_transpile_time(start_time, end_time):
-    log_msg = "Total Transpile Time - %.5f (ms)" % ((end_time - start_time) * 1000)
+    log_msg = f"Total Transpile Time - {((end_time - start_time) * 1000):.5f} (ms)"
     logger.info(log_msg)
 
 
-def _parse_inst_map(inst_map, backend):
-    # try getting inst_map from user, else backend
-    if inst_map is None and backend is not None:
-        inst_map = backend.target.instruction_schedule_map()
-    return inst_map
-
-
-def _parse_coupling_map(coupling_map, backend):
-    # try getting coupling_map from user, else backend
-    if coupling_map is None and backend is not None:
-        coupling_map = backend.coupling_map
-
+def _parse_coupling_map(coupling_map):
     # coupling_map could be None, or a list of lists, e.g. [[0, 1], [2, 1]]
-    if coupling_map is None or isinstance(coupling_map, CouplingMap):
-        return coupling_map
     if isinstance(coupling_map, list) and all(
         isinstance(i, list) and len(i) == 2 for i in coupling_map
     ):
         return CouplingMap(coupling_map)
-    else:
+    elif isinstance(coupling_map, list):
         raise TranspilerError(
             "Only a single input coupling map can be used with transpile() if you need to "
             "target different coupling maps for different circuits you must call transpile() "
             "multiple times"
         )
-
-
-def _parse_initial_layout(initial_layout):
-    # initial_layout could be None, or a list of ints, e.g. [0, 5, 14]
-    # or a list of tuples/None e.g. [qr[0], None, qr[1]] or a dict e.g. {qr[0]: 0}
-    if initial_layout is None or isinstance(initial_layout, Layout):
-        return initial_layout
-    if isinstance(initial_layout, dict):
-        return Layout(initial_layout)
-    initial_layout = list(initial_layout)
-    if all(phys is None or isinstance(phys, Qubit) for phys in initial_layout):
-        return Layout.from_qubit_list(initial_layout)
-    return initial_layout
-
-
-def _parse_instruction_durations(backend, inst_durations, dt):
-    """Create a list of ``InstructionDuration``s. If ``inst_durations`` is provided,
-    the backend will be ignored, otherwise, the durations will be populated from the
-    backend.
-    """
-    final_durations = InstructionDurations()
-    if not inst_durations:
-        backend_durations = InstructionDurations()
-        if backend is not None:
-            backend_durations = backend.instruction_durations
-        final_durations.update(backend_durations, dt or backend_durations.dt)
     else:
-        final_durations.update(inst_durations, dt or getattr(inst_durations, "dt", None))
-    return final_durations
-
-
-def _parse_approximation_degree(approximation_degree):
-    if approximation_degree is None:
-        return None
-    if approximation_degree < 0.0 or approximation_degree > 1.0:
-        raise TranspilerError("Approximation degree must be in [0.0, 1.0]")
-    return approximation_degree
+        return coupling_map
 
 
 def _parse_output_name(output_name, circuits):
@@ -545,17 +469,7 @@ def _parse_output_name(output_name, circuits):
         else:
             raise TranspilerError(
                 "The parameter output_name should be a string or a"
-                "list of strings: %s was used." % type(output_name)
+                f"list of strings: {type(output_name)} was used."
             )
     else:
         return [circuit.name for circuit in circuits]
-
-
-def _parse_timing_constraints(backend, timing_constraints):
-    if isinstance(timing_constraints, TimingConstraints):
-        return timing_constraints
-    if backend is None and timing_constraints is None:
-        timing_constraints = TimingConstraints()
-    elif backend is not None:
-        timing_constraints = backend.target.timing_constraints()
-    return timing_constraints

qiskit/converters/circuit_to_dag.py

@@ -11,9 +11,8 @@
 # that they have been altered from the originals.
 
 """Helper function for converting a circuit to a dag"""
-import copy
 
-from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
 
 
 def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_order=None):
@@ -93,10 +92,9 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
         dagcircuit.add_creg(register)
 
     for instruction in circuit.data:
-        op = instruction.operation
-        if copy_operations:
-            op = copy.deepcopy(op)
-        dagcircuit.apply_operation_back(op, instruction.qubits, instruction.clbits, check=False)
+        dagcircuit._apply_op_node_back(
+            DAGOpNode.from_instruction(instruction, dag=dagcircuit, deepcopy=copy_operations)
+        )
 
     dagcircuit.duration = circuit.duration
     dagcircuit.unit = circuit.unit

qiskit/converters/circuit_to_gate.py

@@ -64,10 +64,8 @@ def circuit_to_gate(circuit, parameter_map=None, equivalence_library=None, label
     for instruction in circuit.data:
         if not _check_is_gate(instruction.operation):
             raise QiskitError(
-                (
-                    "One or more instructions cannot be converted to"
-                    ' a gate. "{}" is not a gate instruction'
-                ).format(instruction.operation.name)
+                "One or more instructions cannot be converted to"
+                f' a gate. "{instruction.operation.name}" is not a gate instruction'
             )
 
     if parameter_map is None:
@@ -77,10 +75,8 @@ def circuit_to_gate(circuit, parameter_map=None, equivalence_library=None, label
 
     if parameter_dict.keys() != circuit.parameters:
         raise QiskitError(
-            (
-                "parameter_map should map all circuit parameters. "
-                "Circuit parameters: {}, parameter_map: {}"
-            ).format(circuit.parameters, parameter_dict)
+            "parameter_map should map all circuit parameters. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {parameter_dict}"
         )
 
     gate = Gate(

qiskit/converters/circuit_to_instruction.py

@@ -11,7 +11,6 @@
 # that they have been altered from the originals.
 
 """Helper function for converting a circuit to an instruction."""
-from qiskit.circuit.parametertable import ParameterTable, ParameterReferences
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.quantumregister import QuantumRegister
@@ -63,7 +62,7 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
 
     if circuit.num_input_vars:
         # This could be supported by moving the `input` variables to be parameters of the
-        # instruction, but we don't really have a good reprssentation of that yet, so safer to
+        # instruction, but we don't really have a good representation of that yet, so safer to
         # forbid it.
         raise QiskitError("Circuits with 'input' variables cannot yet be converted to instructions")
     if circuit.num_captured_vars:
@@ -90,10 +89,8 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
 
     if parameter_dict.keys() != circuit.parameters:
         raise QiskitError(
-            (
-                "parameter_map should map all circuit parameters. "
-                "Circuit parameters: {}, parameter_map: {}"
-            ).format(circuit.parameters, parameter_dict)
+            "parameter_map should map all circuit parameters. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {parameter_dict}"
         )
 
     out_instruction = Instruction(
@@ -121,7 +118,7 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
         regs.append(creg)
 
     clbit_map = {bit: creg[idx] for idx, bit in enumerate(circuit.clbits)}
-    operation_map = {id(ParameterTable.GLOBAL_PHASE): ParameterTable.GLOBAL_PHASE}
+    operation_map = {}
 
     def fix_condition(op):
         original_id = id(op)
@@ -145,19 +142,10 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
 
     data = target._data.copy()
     data.replace_bits(qubits=qreg, clbits=creg)
-    data.map_ops(fix_condition)
+    data.map_nonstandard_ops(fix_condition)
 
     qc = QuantumCircuit(*regs, name=out_instruction.name)
     qc._data = data
-    qc._parameter_table = ParameterTable(
-        {
-            param: ParameterReferences(
-                (operation_map[id(operation)], param_index)
-                for operation, param_index in target._parameter_table[param]
-            )
-            for param in target._parameter_table
-        }
-    )
 
     if circuit.global_phase:
         qc.global_phase = circuit.global_phase

qiskit/converters/dag_to_circuit.py

@@ -11,9 +11,8 @@
 # that they have been altered from the originals.
 
 """Helper function for converting a dag to a circuit."""
-import copy
 
-from qiskit.circuit import QuantumCircuit, CircuitInstruction
+from qiskit.circuit import QuantumCircuit
 
 
 def dag_to_circuit(dag, copy_operations=True):
@@ -71,10 +70,7 @@ def dag_to_circuit(dag, copy_operations=True):
     circuit.calibrations = dag.calibrations
 
     for node in dag.topological_op_nodes():
-        op = node.op
-        if copy_operations:
-            op = copy.deepcopy(op)
-        circuit._append(CircuitInstruction(op, node.qargs, node.cargs))
+        circuit._append(node._to_circuit_instruction(deepcopy=copy_operations))
 
     circuit.duration = dag.duration
     circuit.unit = dag.unit

qiskit/dagcircuit/collect_blocks.py

@@ -288,8 +288,8 @@ class BlockSplitter:
             self.group[self.find_leader(first)].append(node)
 
         blocks = []
-        for index in self.leader:
-            if self.leader[index] == index:
+        for index, item in self.leader.items():
+            if index == item:
                 blocks.append(self.group[index])
 
         return blocks