Continue removal: use of FakePulseBackends in tests, classes that depend on functionality that depends on qobj, related tests.

Author: ElePT

qiskit/__init__.py

@@ -127,7 +127,7 @@
 
 _config = _user_config.get_config()
 
-from qiskit.compiler import transpile, schedule, sequence
+from qiskit.compiler import transpile
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from .version import __version__
 
@@ -138,8 +138,6 @@
     "QiskitError",
     "QuantumCircuit",
     "QuantumRegister",
-    "schedule",
-    "sequence",
     "transpile",
     "generate_preset_pass_manager",
 ]

qiskit/compiler/__init__.py

@@ -20,12 +20,8 @@
 Circuit and Pulse Compilation Functions
 =======================================
 
-.. autofunction:: schedule
 .. autofunction:: transpile
-.. autofunction:: sequence
 
 """
 
 from .transpiler import transpile
-from .scheduler import schedule
-from .sequencer import sequence

qiskit/compiler/scheduler.py

@@ -66,12 +66,10 @@
     additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
     "with defined properties with Target.from_configuration(..., backend_properties=...)",
 )
-@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
 def transpile(  # pylint: disable=too-many-return-statements
     circuits: _CircuitT,
     backend: Optional[Backend] = None,
     basis_gates: Optional[List[str]] = None,
-    inst_map: Optional[List[InstructionScheduleMap]] = None,
     coupling_map: Optional[Union[CouplingMap, List[List[int]]]] = None,
     backend_properties: Optional[BackendProperties] = None,
     initial_layout: Optional[Union[Layout, Dict, List]] = None,
@@ -105,7 +103,7 @@ def transpile(  # pylint: disable=too-many-return-statements
 
     The prioritization of transpilation target constraints works as follows: if a ``target``
     input is provided, it will take priority over any ``backend`` input or loose constraints
-    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
+    (``basis_gates``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
     ``dt`` or ``timing_constraints``). If a ``backend`` is provided together with any loose constraint
     from the list above, the loose constraint will take priority over the corresponding backend
     constraint. This behavior is independent of whether the ``backend`` instance is of type
@@ -120,7 +118,6 @@ def transpile(  # pylint: disable=too-many-return-statements
     **basis_gates**              target    basis_gates              basis_gates
     **coupling_map**             target    coupling_map             coupling_map
     **instruction_durations**    target    instruction_durations    instruction_durations
-    **inst_map**                 target    inst_map                 inst_map
     **dt**                       target    dt                       dt
     **timing_constraints**       target    timing_constraints       timing_constraints
     **backend_properties**       target    backend_properties       backend_properties
@@ -133,12 +130,6 @@ def transpile(  # pylint: disable=too-many-return-statements
             will override the backend's.
         basis_gates: List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``). If ``None``, do not unroll.
-        inst_map: DEPRECATED. Mapping of unrolled gates to pulse schedules. If this is not provided,
-            transpiler tries to get from the backend. If any user defined calibration
-            is found in the map and this is used in a circuit, transpiler attaches
-            the custom gate definition to the circuit. This enables one to flexibly
-            override the low-level instruction implementation. This feature is available
-            iff the backend supports the pulse gate experiment.
         coupling_map: Directed coupling map (perhaps custom) to target in mapping. If
             the coupling map is symmetric, both directions need to be specified.
 
@@ -394,14 +385,8 @@ def callback_func(**kwargs):
     # 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.
-    # Filter instruction_durations, timing_constraints, backend_properties and inst_map deprecation
+    # Filter instruction_durations, timing_constraints, backend_properties deprecation
     with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
         warnings.filterwarnings(
             "ignore",
             category=DeprecationWarning,
@@ -429,7 +414,6 @@ def callback_func(**kwargs):
             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,

qiskit/compiler/sequencer.py

@@ -24,10 +24,9 @@
 from qiskit.circuit.delay import Delay
 from qiskit.circuit.measure import Measure
 from qiskit.circuit.reset import Reset
-from qiskit.providers.models.pulsedefaults import PulseDefaults
 
 
-def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict = None) -> Target:
+def convert_to_target(conf_dict: dict, props_dict: dict = None) -> Target:
     """Uses configuration, properties and pulse defaults dicts
     to construct and return Target class.
     """
@@ -107,25 +106,7 @@ def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict
         target.pulse_alignment = conf_dict["timing_constraints"].get("pulse_alignment")
         target.acquire_alignment = conf_dict["timing_constraints"].get("acquire_alignment")
     # If pulse defaults exists use that as the source of truth
-    if defs_dict is not None:
-        # TODO remove the usage of PulseDefaults as it will be deprecated in the future
-        pulse_defs = PulseDefaults.from_dict(defs_dict)
-        inst_map = pulse_defs.instruction_schedule_map
-        for inst in inst_map.instructions:
-            for qarg in inst_map.qubits_with_instruction(inst):
-                try:
-                    qargs = tuple(qarg)
-                except TypeError:
-                    qargs = (qarg,)
-                # Do NOT call .get method. This parses Qpbj immediately.
-                # This operation is computationally expensive and should be bypassed.
-                calibration_entry = inst_map._get_calibration_entry(inst, qargs)
-                if inst in target:
-                    if inst == "measure":
-                        for qubit in qargs:
-                            target[inst][(qubit,)].calibration = calibration_entry
-                    elif qargs in target[inst]:
-                        target[inst][qargs].calibration = calibration_entry
+
     target.add_instruction(
         Delay(Parameter("t")), {(bit,): None for bit in range(target.num_qubits)}
     )

qiskit/compiler/transpiler.py

@@ -85,7 +85,6 @@
    RemoveFinalReset
    HoareOptimizer
    TemplateOptimization
-   EchoRZXWeylDecomposition
    ResetAfterMeasureSimplification
    OptimizeCliffords
    ElidePermutations
@@ -237,7 +236,6 @@
 from .optimization import HoareOptimizer
 from .optimization import TemplateOptimization
 from .optimization import InverseCancellation
-from .optimization import EchoRZXWeylDecomposition
 from .optimization import CollectAndCollapse
 from .optimization import CollectLinearFunctions
 from .optimization import CollectCliffords

qiskit/providers/fake_provider/utils/backend_converter.py

@@ -29,7 +29,6 @@
 from .template_optimization import TemplateOptimization
 from .inverse_cancellation import InverseCancellation
 from .collect_1q_runs import Collect1qRuns
-from .echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
 from .collect_linear_functions import CollectLinearFunctions
 from .reset_after_measure_simplification import ResetAfterMeasureSimplification
 from .optimize_cliffords import OptimizeCliffords