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

qiskit/circuit/quantumcircuitdata.py

@@ -45,8 +45,6 @@ class QuantumCircuitData(MutableSequence):
             operation, qargs, cargs = value
         value = self._resolve_legacy_value(operation, qargs, cargs)
         self._circuit._data[key] = value
-        if isinstance(value.operation, Instruction):
-            self._circuit._update_parameter_table(value.operation)
 
     def _resolve_legacy_value(self, operation, qargs, cargs) -> CircuitInstruction:
         """Resolve the old-style 3-tuple into the new :class:`CircuitInstruction` type."""
@@ -55,8 +53,8 @@ class QuantumCircuitData(MutableSequence):
         if not isinstance(operation, Operation):
             raise CircuitError("object is not an Operation.")
 
-        expanded_qargs = [self._circuit.qbit_argument_conversion(qarg) for qarg in qargs or []]
-        expanded_cargs = [self._circuit.cbit_argument_conversion(carg) for carg in cargs or []]
+        expanded_qargs = [self._circuit._qbit_argument_conversion(qarg) for qarg in qargs or []]
+        expanded_cargs = [self._circuit._cbit_argument_conversion(carg) for carg in cargs or []]
 
         if isinstance(operation, Instruction):
             broadcast_args = list(operation.broadcast_arguments(expanded_qargs, expanded_cargs))
@@ -76,7 +74,7 @@ class QuantumCircuitData(MutableSequence):
         return CircuitInstruction(operation, tuple(qargs), tuple(cargs))
 
     def insert(self, index, value):
-        self._circuit._data.insert(index, CircuitInstruction(None, (), ()))
+        self._circuit._data.insert(index, value.replace(qubits=(), clbits=()))
         try:
             self[index] = value
         except CircuitError:

qiskit/circuit/quantumregister.py

@@ -43,7 +43,7 @@ class Qubit(Bit):
             super().__init__(register, index)
         else:
             raise CircuitError(
-                "Qubit needs a QuantumRegister and %s was provided" % type(register).__name__
+                f"Qubit needs a QuantumRegister and {type(register).__name__} was provided"
             )
 
 

qiskit/circuit/random/__init__.py

@@ -12,4 +12,4 @@
 
 """Method for generating random circuits."""
 
-from .utils import random_circuit
+from .utils import random_circuit, random_clifford_circuit

qiskit/circuit/random/utils.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017.
+# (C) Copyright IBM 2017, 2024.
 #
 # 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
@@ -18,10 +18,18 @@ from qiskit.circuit import ClassicalRegister, QuantumCircuit, CircuitInstruction
 from qiskit.circuit import Reset
 from qiskit.circuit.library import standard_gates
 from qiskit.circuit.exceptions import CircuitError
+from qiskit.quantum_info.operators.symplectic.clifford_circuits import _BASIS_1Q, _BASIS_2Q
 
 
 def random_circuit(
-    num_qubits, depth, max_operands=4, measure=False, conditional=False, reset=False, seed=None
+    num_qubits,
+    depth,
+    max_operands=4,
+    measure=False,
+    conditional=False,
+    reset=False,
+    seed=None,
+    num_operand_distribution: dict = None,
 ):
     """Generate random circuit of arbitrary size and form.
 
@@ -44,6 +52,10 @@ def random_circuit(
         conditional (bool): if True, insert middle measurements and conditionals
         reset (bool): if True, insert middle resets
         seed (int): sets random seed (optional)
+        num_operand_distribution (dict): a distribution of gates that specifies the ratio
+        of 1-qubit, 2-qubit, 3-qubit, ..., n-qubit gates in the random circuit. Expect a
+        deviation from the specified ratios that depends on the size of the requested
+        random circuit. (optional)
 
     Returns:
         QuantumCircuit: constructed circuit
@@ -51,11 +63,38 @@ def random_circuit(
     Raises:
         CircuitError: when invalid options given
     """
+    if seed is None:
+        seed = np.random.randint(0, np.iinfo(np.int32).max)
+    rng = np.random.default_rng(seed)
+
+    if num_operand_distribution:
+        if min(num_operand_distribution.keys()) < 1 or max(num_operand_distribution.keys()) > 4:
+            raise CircuitError("'num_operand_distribution' must have keys between 1 and 4")
+        for key, prob in num_operand_distribution.items():
+            if key > num_qubits and prob != 0.0:
+                raise CircuitError(
+                    f"'num_operand_distribution' cannot have {key}-qubit gates"
+                    f" for circuit with {num_qubits} qubits"
+                )
+        num_operand_distribution = dict(sorted(num_operand_distribution.items()))
+
+    if not num_operand_distribution and max_operands:
+        if max_operands < 1 or max_operands > 4:
+            raise CircuitError("max_operands must be between 1 and 4")
+        max_operands = max_operands if num_qubits > max_operands else num_qubits
+        rand_dist = rng.dirichlet(
+            np.ones(max_operands)
+        )  # This will create a random distribution that sums to 1
+        num_operand_distribution = {i + 1: rand_dist[i] for i in range(max_operands)}
+        num_operand_distribution = dict(sorted(num_operand_distribution.items()))
+
+    # Here we will use np.isclose() because very rarely there might be floating
+    # point precision errors
+    if not np.isclose(sum(num_operand_distribution.values()), 1):
+        raise CircuitError("The sum of all the values in 'num_operand_distribution' is not 1.")
+
     if num_qubits == 0:
         return QuantumCircuit()
-    if max_operands < 1 or max_operands > 4:
-        raise CircuitError("max_operands must be between 1 and 4")
-    max_operands = max_operands if num_qubits > max_operands else num_qubits
 
     gates_1q = [
         # (Gate class, number of qubits, number of parameters)
@@ -119,17 +158,26 @@ def random_circuit(
         (standard_gates.RC3XGate, 4, 0),
     ]
 
-    gates = gates_1q.copy()
-    if max_operands >= 2:
-        gates.extend(gates_2q)
-    if max_operands >= 3:
-        gates.extend(gates_3q)
-    if max_operands >= 4:
-        gates.extend(gates_4q)
-    gates = np.array(
-        gates, dtype=[("class", object), ("num_qubits", np.int64), ("num_params", np.int64)]
+    gates_1q = np.array(
+        gates_1q, dtype=[("class", object), ("num_qubits", np.int64), ("num_params", np.int64)]
     )
-    gates_1q = np.array(gates_1q, dtype=gates.dtype)
+    gates_2q = np.array(gates_2q, dtype=gates_1q.dtype)
+    gates_3q = np.array(gates_3q, dtype=gates_1q.dtype)
+    gates_4q = np.array(gates_4q, dtype=gates_1q.dtype)
+
+    all_gate_lists = [gates_1q, gates_2q, gates_3q, gates_4q]
+
+    # Here we will create a list 'gates_to_consider' that will have a
+    # subset of different n-qubit gates and will also create a list for
+    # ratio (or probability) for each gates
+    gates_to_consider = []
+    distribution = []
+    for n_qubits, ratio in num_operand_distribution.items():
+        gate_list = all_gate_lists[n_qubits - 1]
+        gates_to_consider.extend(gate_list)
+        distribution.extend([ratio / len(gate_list)] * len(gate_list))
+
+    gates = np.array(gates_to_consider, dtype=gates_1q.dtype)
 
     qc = QuantumCircuit(num_qubits)
 
@@ -137,33 +185,65 @@ def random_circuit(
         cr = ClassicalRegister(num_qubits, "c")
         qc.add_register(cr)
 
-    if seed is None:
-        seed = np.random.randint(0, np.iinfo(np.int32).max)
-    rng = np.random.default_rng(seed)
-
     qubits = np.array(qc.qubits, dtype=object, copy=True)
 
+    # Counter to keep track of number of different gate types
+    counter = np.zeros(len(all_gate_lists) + 1, dtype=np.int64)
+    total_gates = 0
+
     # Apply arbitrary random operations in layers across all qubits.
     for layer_number in range(depth):
         # We generate all the randomness for the layer in one go, to avoid many separate calls to
-        # the randomisation routines, which can be fairly slow.
+        # the randomization routines, which can be fairly slow.
 
         # This reliably draws too much randomness, but it's less expensive than looping over more
         # calls to the rng. After, trim it down by finding the point when we've used all the qubits.
-        gate_specs = rng.choice(gates, size=len(qubits))
+
+        # Due to the stochastic nature of generating a random circuit, the resulting ratios
+        # may not precisely match the specified values from `num_operand_distribution`. Expect
+        # greater deviations from the target ratios in quantum circuits with fewer qubits and
+        # shallower depths, and smaller deviations in larger and deeper quantum circuits.
+        # For more information on how the distribution changes with number of qubits and depth
+        # refer to the pull request #12483 on Qiskit GitHub.
+
+        gate_specs = rng.choice(gates, size=len(qubits), p=distribution)
         cumulative_qubits = np.cumsum(gate_specs["num_qubits"], dtype=np.int64)
+
         # Efficiently find the point in the list where the total gates would use as many as
         # possible of, but not more than, the number of qubits in the layer.  If there's slack, fill
         # it with 1q gates.
         max_index = np.searchsorted(cumulative_qubits, num_qubits, side="right")
         gate_specs = gate_specs[:max_index]
+
         slack = num_qubits - cumulative_qubits[max_index - 1]
-        if slack:
-            gate_specs = np.hstack((gate_specs, rng.choice(gates_1q, size=slack)))
 
-        # For efficiency in the Python loop, this uses Numpy vectorisation to pre-calculate the
+        # Updating the counter for 1-qubit, 2-qubit, 3-qubit and 4-qubit gates
+        gate_qubits = gate_specs["num_qubits"]
+        counter += np.bincount(gate_qubits, minlength=len(all_gate_lists) + 1)
+
+        total_gates += len(gate_specs)
+
+        # Slack handling loop, this loop will add gates to fill
+        # the slack while respecting the 'num_operand_distribution'
+        while slack > 0:
+            gate_added_flag = False
+
+            for key, dist in sorted(num_operand_distribution.items(), reverse=True):
+                if slack >= key and counter[key] / total_gates < dist:
+                    gate_to_add = np.array(
+                        all_gate_lists[key - 1][rng.integers(0, len(all_gate_lists[key - 1]))]
+                    )
+                    gate_specs = np.hstack((gate_specs, gate_to_add))
+                    counter[key] += 1
+                    total_gates += 1
+                    slack -= key
+                    gate_added_flag = True
+            if not gate_added_flag:
+                break
+
+        # For efficiency in the Python loop, this uses Numpy vectorization to pre-calculate the
         # indices into the lists of qubits and parameters for every gate, and then suitably
-        # randomises those lists.
+        # randomizes those lists.
         q_indices = np.empty(len(gate_specs) + 1, dtype=np.int64)
         p_indices = np.empty(len(gate_specs) + 1, dtype=np.int64)
         q_indices[0] = p_indices[0] = 0
@@ -202,8 +282,77 @@ def random_circuit(
             ):
                 operation = gate(*parameters[p_start:p_end])
                 qc._append(CircuitInstruction(operation=operation, qubits=qubits[q_start:q_end]))
-
     if measure:
         qc.measure(qc.qubits, cr)
 
     return qc
+
+
+def random_clifford_circuit(num_qubits, num_gates, gates="all", seed=None):
+    """Generate a pseudo-random Clifford circuit.
+
+    This function will generate a Clifford circuit by randomly selecting the chosen amount of Clifford
+    gates from the set of standard gates in :mod:`qiskit.circuit.library.standard_gates`. For example:
+
+    .. plot::
+       :include-source:
+
+       from qiskit.circuit.random import random_clifford_circuit
+
+       circ = random_clifford_circuit(num_qubits=2, num_gates=6)
+       circ.draw(output='mpl')
+
+    Args:
+        num_qubits (int): number of quantum wires.
+        num_gates (int): number of gates in the circuit.
+        gates (list[str]): optional list of Clifford gate names to randomly sample from.
+            If ``"all"`` (default), use all Clifford gates in the standard library.
+        seed (int | np.random.Generator): sets random seed/generator (optional).
+
+    Returns:
+        QuantumCircuit: constructed circuit
+    """
+
+    gates_1q = list(set(_BASIS_1Q.keys()) - {"v", "w", "id", "iden", "sinv"})
+    gates_2q = list(_BASIS_2Q.keys())
+
+    if gates == "all":
+        if num_qubits == 1:
+            gates = gates_1q
+        else:
+            gates = gates_1q + gates_2q
+
+    instructions = {
+        "i": (standard_gates.IGate(), 1),
+        "x": (standard_gates.XGate(), 1),
+        "y": (standard_gates.YGate(), 1),
+        "z": (standard_gates.ZGate(), 1),
+        "h": (standard_gates.HGate(), 1),
+        "s": (standard_gates.SGate(), 1),
+        "sdg": (standard_gates.SdgGate(), 1),
+        "sx": (standard_gates.SXGate(), 1),
+        "sxdg": (standard_gates.SXdgGate(), 1),
+        "cx": (standard_gates.CXGate(), 2),
+        "cy": (standard_gates.CYGate(), 2),
+        "cz": (standard_gates.CZGate(), 2),
+        "swap": (standard_gates.SwapGate(), 2),
+        "iswap": (standard_gates.iSwapGate(), 2),
+        "ecr": (standard_gates.ECRGate(), 2),
+        "dcx": (standard_gates.DCXGate(), 2),
+    }
+
+    if isinstance(seed, np.random.Generator):
+        rng = seed
+    else:
+        rng = np.random.default_rng(seed)
+
+    samples = rng.choice(gates, num_gates)
+
+    circ = QuantumCircuit(num_qubits)
+
+    for name in samples:
+        gate, nqargs = instructions[name]
+        qargs = rng.choice(range(num_qubits), nqargs, replace=False).tolist()
+        circ.append(gate, qargs, copy=False)
+
+    return circ

qiskit/circuit/register.py

@@ -67,7 +67,7 @@ class Register:
         if (size, bits) == (None, None) or (size is not None and bits is not None):
             raise CircuitError(
                 "Exactly one of the size or bits arguments can be "
-                "provided. Provided size=%s bits=%s." % (size, bits)
+                f"provided. Provided size={size} bits={bits}."
             )
 
         # validate (or cast) size
@@ -81,20 +81,18 @@ class Register:
 
         if not valid_size:
             raise CircuitError(
-                "Register size must be an integer. (%s '%s' was provided)"
-                % (type(size).__name__, size)
+                f"Register size must be an integer. ({type(size).__name__} '{size}' was provided)"
             )
         size = int(size)  # cast to int
 
         if size < 0:
             raise CircuitError(
-                "Register size must be non-negative (%s '%s' was provided)"
-                % (type(size).__name__, size)
+                f"Register size must be non-negative ({type(size).__name__} '{size}' was provided)"
             )
 
         # validate (or cast) name
         if name is None:
-            name = "%s%i" % (self.prefix, next(self.instances_counter))
+            name = f"{self.prefix}{next(self.instances_counter)}"
         else:
             try:
                 name = str(name)
@@ -108,7 +106,7 @@ class Register:
         self._size = size
 
         self._hash = hash((type(self), self._name, self._size))
-        self._repr = "%s(%d, '%s')" % (self.__class__.__qualname__, self.size, self.name)
+        self._repr = f"{self.__class__.__qualname__}({self.size}, '{self.name}')"
         if bits is not None:
             # check duplicated bits
             if self._size != len(set(bits)):

qiskit/circuit/singleton.py

@@ -42,7 +42,7 @@ The same can be true for, for example, :class:`.Measure`, except that it's a sub
     heart of Qiskit's data model for circuits.
 
 From a library-author perspective, the minimum that is needed to enhance a :class:`.Gate` or
-:class:`~.circuit.Instruction` with this behaviour is to inherit from :class:`SingletonGate`
+:class:`~.circuit.Instruction` with this behavior is to inherit from :class:`SingletonGate`
 (:class:`SingletonInstruction`) instead of :class:`.Gate` (:class:`~.circuit.Instruction`), and for
 the ``__init__`` method to have defaults for all of its arguments (these will be the state of the
 singleton instance).  For example::
@@ -175,7 +175,7 @@ Implementation
     This section is primarily developer documentation for the code; none of the machinery described
     here is public, and it is not safe to inherit from any of it directly.
 
-There are several moving parts to tackle here.  The behaviour of having ``XGate()`` return some
+There are several moving parts to tackle here.  The behavior of having ``XGate()`` return some
 singleton object that is an (inexact) instance of :class:`.XGate` but *without* calling ``__init__``
 requires us to override :class:`type.__call__ <type>`.  This means that :class:`.XGate` must have a
 metaclass that defines ``__call__`` to return the singleton instance.
@@ -484,7 +484,7 @@ class _SingletonInstructionOverrides(Instruction):
         instruction._define()
         # We use this `list` subclass that rejects all mutation rather than a simple `tuple` because
         # the `params` typing is specified as `list`. Various places in the library and beyond do
-        # `x.params.copy()` when they want to produce a version they own, which is good behaviour,
+        # `x.params.copy()` when they want to produce a version they own, which is good behavior,
         # and would fail if we switched to a `tuple`, which has no `copy` method.
         instruction._params = _frozenlist(instruction._params)
         return instruction

qiskit/circuit/tools/pi_check.py

@@ -104,9 +104,9 @@ def pi_check(inpt, eps=1e-9, output="text", ndigits=None):
             if power[0].shape[0]:
                 if output == "qasm":
                     if ndigits is None:
-                        str_out = "{}".format(single_inpt)
+                        str_out = str(single_inpt)
                     else:
-                        str_out = "{:.{}g}".format(single_inpt, ndigits)
+                        str_out = f"{single_inpt:.{ndigits}g}"
                 elif output == "latex":
                     str_out = f"{neg_str}{pi}^{power[0][0] + 2}"
                 elif output == "mpl":
@@ -119,9 +119,9 @@ def pi_check(inpt, eps=1e-9, output="text", ndigits=None):
         # multiple or power of pi, since no fractions will exceed MAX_FRAC * pi
         if abs(single_inpt) >= (MAX_FRAC * np.pi):
             if ndigits is None:
-                str_out = "{}".format(single_inpt)
+                str_out = str(single_inpt)
             else:
-                str_out = "{:.{}g}".format(single_inpt, ndigits)
+                str_out = f"{single_inpt:.{ndigits}g}"
             return str_out
 
         # Fourth check is for fractions for 1*pi in the numer and any

qiskit/compiler/assembler.py

@@ -20,7 +20,7 @@ from typing import Dict, List, Optional, Union
 
 import numpy as np
 
-from qiskit.assembler import assemble_circuits, assemble_schedules
+from qiskit.assembler import assemble_schedules
 from qiskit.assembler.run_config import RunConfig
 from qiskit.circuit import Parameter, QuantumCircuit, Qubit
 from qiskit.exceptions import QiskitError
@@ -29,16 +29,26 @@ from qiskit.pulse import Instruction, LoConfig, Schedule, ScheduleBlock
 from qiskit.pulse.channels import PulseChannel
 from qiskit.qobj import QasmQobj, PulseQobj, QobjHeader
 from qiskit.qobj.utils import MeasLevel, MeasReturnType
+from qiskit.utils import deprecate_func
+from qiskit.assembler.assemble_circuits import _assemble_circuits
 
 logger = logging.getLogger(__name__)
 
 
 def _log_assembly_time(start_time, end_time):
-    log_msg = "Total Assembly Time - %.5f (ms)" % ((end_time - start_time) * 1000)
+    log_msg = f"Total Assembly Time - {((end_time - start_time) * 1000):.5f} (ms)"
     logger.info(log_msg)
 
 
 # TODO: parallelize over the experiments (serialize each separately, then add global header/config)
+@deprecate_func(
+    since="1.2",
+    removal_timeline="in the 2.0 release",
+    additional_msg="The `Qobj` class and related functionality are part of the deprecated "
+    "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
+    "workflow requires `Qobj` it likely relies on deprecated functionality and "
+    "should be updated to use `BackendV2`.",
+)
 def assemble(
     experiments: Union[
         QuantumCircuit,
@@ -81,7 +91,7 @@ def assemble(
     to create ``Qobj`` "experiments". It further annotates the experiment payload with
     header and configurations.
 
-    NOTE: Backend.options is not used within assemble. The required values
+    NOTE: ``Backend.options`` is not used within assemble. The required values
     (previously given by backend.set_options) should be manually extracted
     from options and supplied directly when calling.
 
@@ -153,27 +163,92 @@ def assemble(
     Raises:
         QiskitError: if the input cannot be interpreted as either circuits or schedules
     """
-    start_time = time()
-    experiments = experiments if isinstance(experiments, list) else [experiments]
-    pulse_qobj = any(isinstance(exp, (ScheduleBlock, Schedule, Instruction)) for exp in experiments)
-    qobj_id, qobj_header, run_config_common_dict = _parse_common_args(
+    return _assemble(
+        experiments,
         backend,
         qobj_id,
         qobj_header,
         shots,
         memory,
         seed_simulator,
-        init_qubits,
-        rep_delay,
         qubit_lo_freq,
         meas_lo_freq,
         qubit_lo_range,
         meas_lo_range,
         schedule_los,
-        pulse_qobj=pulse_qobj,
+        meas_level,
+        meas_return,
+        meas_map,
+        memory_slot_size,
+        rep_time,
+        rep_delay,
+        parameter_binds,
+        parametric_pulses,
+        init_qubits,
         **run_config,
     )
 
+
+def _assemble(
+    experiments: Union[
+        QuantumCircuit,
+        List[QuantumCircuit],
+        Schedule,
+        List[Schedule],
+        ScheduleBlock,
+        List[ScheduleBlock],
+    ],
+    backend: Optional[Backend] = None,
+    qobj_id: Optional[str] = None,
+    qobj_header: Optional[Union[QobjHeader, Dict]] = None,
+    shots: Optional[int] = None,
+    memory: Optional[bool] = False,
+    seed_simulator: Optional[int] = None,
+    qubit_lo_freq: Optional[List[float]] = None,
+    meas_lo_freq: Optional[List[float]] = None,
+    qubit_lo_range: Optional[List[float]] = None,
+    meas_lo_range: Optional[List[float]] = None,
+    schedule_los: Optional[
+        Union[
+            List[Union[Dict[PulseChannel, float], LoConfig]],
+            Union[Dict[PulseChannel, float], LoConfig],
+        ]
+    ] = None,
+    meas_level: Union[int, MeasLevel] = MeasLevel.CLASSIFIED,
+    meas_return: Union[str, MeasReturnType] = MeasReturnType.AVERAGE,
+    meas_map: Optional[List[List[Qubit]]] = None,
+    memory_slot_size: int = 100,
+    rep_time: Optional[int] = None,
+    rep_delay: Optional[float] = None,
+    parameter_binds: Optional[List[Dict[Parameter, float]]] = None,
+    parametric_pulses: Optional[List[str]] = None,
+    init_qubits: bool = True,
+    **run_config: Dict,
+) -> Union[QasmQobj, PulseQobj]:
+    start_time = time()
+    experiments = experiments if isinstance(experiments, list) else [experiments]
+    pulse_qobj = any(isinstance(exp, (ScheduleBlock, Schedule, Instruction)) for exp in experiments)
+    with warnings.catch_warnings():
+        # The Qobj is deprecated
+        warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+        qobj_id, qobj_header, run_config_common_dict = _parse_common_args(
+            backend,
+            qobj_id,
+            qobj_header,
+            shots,
+            memory,
+            seed_simulator,
+            init_qubits,
+            rep_delay,
+            qubit_lo_freq,
+            meas_lo_freq,
+            qubit_lo_range,
+            meas_lo_range,
+            schedule_los,
+            pulse_qobj=pulse_qobj,
+            **run_config,
+        )
+
     # assemble either circuits or schedules
     if all(isinstance(exp, QuantumCircuit) for exp in experiments):
         run_config = _parse_circuit_args(
@@ -191,7 +266,7 @@ def assemble(
         )
         end_time = time()
         _log_assembly_time(start_time, end_time)
-        return assemble_circuits(
+        return _assemble_circuits(
             circuits=bound_experiments,
             qobj_id=qobj_id,
             qobj_header=qobj_header,
@@ -311,8 +386,8 @@ def _parse_common_args(
         raise QiskitError("Argument 'shots' should be of type 'int'")
     elif max_shots and max_shots < shots:
         raise QiskitError(
-            "Number of shots specified: %s exceeds max_shots property of the "
-            "backend: %s." % (shots, max_shots)
+            f"Number of shots specified: {max_shots} exceeds max_shots property of the "
+            f"backend: {max_shots}."
         )
 
     dynamic_reprate_enabled = getattr(backend_config, "dynamic_reprate_enabled", False)
@@ -397,9 +472,8 @@ def _check_lo_freqs(
                 raise QiskitError(f"Each element of {lo_type} LO range must be a 2d list.")
             if freq < freq_range[0] or freq > freq_range[1]:
                 raise QiskitError(
-                    "Qubit {} {} LO frequency is {}. The range is [{}, {}].".format(
-                        i, lo_type, freq, freq_range[0], freq_range[1]
-                    )
+                    f"Qubit {i} {lo_type} LO frequency is {freq}. "
+                    f"The range is [{freq_range[0]}, {freq_range[1]}]."
                 )
 
 
@@ -429,9 +503,8 @@ def _parse_pulse_args(
 
         if meas_level not in getattr(backend_config, "meas_levels", [MeasLevel.CLASSIFIED]):
             raise QiskitError(
-                ("meas_level = {} not supported for backend {}, only {} is supported").format(
-                    meas_level, backend_config.backend_name, backend_config.meas_levels
-                )
+                f"meas_level = {meas_level} not supported for backend "
+                f"{backend_config.backend_name}, only {backend_config.meas_levels} is supported"
             )
 
     meas_map = meas_map or getattr(backend_config, "meas_map", None)
@@ -522,14 +595,12 @@ def _parse_rep_delay(
         if rep_delay_range is not None and isinstance(rep_delay_range, list):
             if len(rep_delay_range) != 2:
                 raise QiskitError(
-                    "Backend rep_delay_range {} must be a list with two entries.".format(
-                        rep_delay_range
-                    )
+                    f"Backend rep_delay_range {rep_delay_range} must be a list with two entries."
                 )
             if not rep_delay_range[0] <= rep_delay <= rep_delay_range[1]:
                 raise QiskitError(
-                    "Supplied rep delay {} not in the supported "
-                    "backend range {}".format(rep_delay, rep_delay_range)
+                    f"Supplied rep delay {rep_delay} not in the supported "
+                    f"backend range {rep_delay_range}"
                 )
         rep_delay = rep_delay * 1e6  # convert sec to μs
 

qiskit/compiler/scheduler.py

@@ -23,7 +23,7 @@ from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.exceptions import QiskitError
 from qiskit.pulse import InstructionScheduleMap, Schedule
 from qiskit.providers.backend import Backend
-from qiskit.scheduler import ScheduleConfig
+from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.schedule_circuit import schedule_circuit
 from qiskit.utils.parallel import parallel_map
 
@@ -31,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 
 def _log_schedule_time(start_time, end_time):
-    log_msg = "Total Scheduling Time - %.5f (ms)" % ((end_time - start_time) * 1000)
+    log_msg = f"Total Scheduling Time - {((end_time - start_time) * 1000):.5f} (ms)"
     logger.info(log_msg)