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

qiskit/providers/fake_provider/generic_backend_v2.py

@@ -112,6 +112,8 @@ class GenericBackendV2(BackendV2):
         calibrate_instructions: bool | InstructionScheduleMap | None = None,
         dtm: float | None = None,
         seed: int | None = None,
+        pulse_channels: bool = True,
+        noise_info: bool = True,
     ):
         """
         Args:
@@ -159,6 +161,10 @@ class GenericBackendV2(BackendV2):
                 None by default.
 
             seed: Optional seed for generation of default values.
+
+            pulse_channels: If true, sets default pulse channel information on the backend.
+
+            noise_info: If true, associates gates and qubits with default noise information.
         """
 
         super().__init__(
@@ -175,6 +181,10 @@ class GenericBackendV2(BackendV2):
         self._control_flow = control_flow
         self._calibrate_instructions = calibrate_instructions
         self._supported_gates = get_standard_gate_name_mapping()
+        self._noise_info = noise_info
+
+        if calibrate_instructions and not noise_info:
+            raise QiskitError("Must set parameter noise_info when calibrating instructions.")
 
         if coupling_map is None:
             self._coupling_map = CouplingMap().from_full(num_qubits)
@@ -198,7 +208,10 @@ class GenericBackendV2(BackendV2):
                 self._basis_gates.append(name)
 
         self._build_generic_target()
-        self._build_default_channels()
+        if pulse_channels:
+            self._build_default_channels()
+        else:
+            self.channels_map = {}
 
     @property
     def target(self):
@@ -253,27 +266,36 @@ class GenericBackendV2(BackendV2):
         # Note that the calibration pulses are different for
         # 1q gates vs 2q gates vs measurement instructions.
         if inst == "measure":
-            sequence = [
-                PulseQobjInstruction(
-                    name="acquire",
-                    duration=1792,
-                    t0=0,
-                    qubits=qargs,
-                    memory_slot=qargs,
-                )
-            ] + [PulseQobjInstruction(name=pulse_library[1].name, ch=f"m{i}", t0=0) for i in qargs]
+            with warnings.catch_warnings():
+                # The class PulseQobjInstruction is deprecated
+                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                sequence = [
+                    PulseQobjInstruction(
+                        name="acquire",
+                        duration=1792,
+                        t0=0,
+                        qubits=qargs,
+                        memory_slot=qargs,
+                    )
+                ] + [
+                    PulseQobjInstruction(name=pulse_library[1].name, ch=f"m{i}", t0=0)
+                    for i in qargs
+                ]
             return sequence
-        if num_qubits == 1:
+        with warnings.catch_warnings():
+            # The class PulseQobjInstruction is deprecated
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            if num_qubits == 1:
+                return [
+                    PulseQobjInstruction(name="fc", ch=f"u{qargs[0]}", t0=0, phase="-P0"),
+                    PulseQobjInstruction(name=pulse_library[0].name, ch=f"d{qargs[0]}", t0=0),
+                ]
             return [
-                PulseQobjInstruction(name="fc", ch=f"u{qargs[0]}", t0=0, phase="-P0"),
-                PulseQobjInstruction(name=pulse_library[0].name, ch=f"d{qargs[0]}", t0=0),
+                PulseQobjInstruction(name=pulse_library[1].name, ch=f"d{qargs[0]}", t0=0),
+                PulseQobjInstruction(name=pulse_library[2].name, ch=f"u{qargs[0]}", t0=0),
+                PulseQobjInstruction(name=pulse_library[1].name, ch=f"d{qargs[1]}", t0=0),
+                PulseQobjInstruction(name="fc", ch=f"d{qargs[1]}", t0=0, phase=2.1),
             ]
-        return [
-            PulseQobjInstruction(name=pulse_library[1].name, ch=f"d{qargs[0]}", t0=0),
-            PulseQobjInstruction(name=pulse_library[2].name, ch=f"u{qargs[0]}", t0=0),
-            PulseQobjInstruction(name=pulse_library[1].name, ch=f"d{qargs[1]}", t0=0),
-            PulseQobjInstruction(name="fc", ch=f"d{qargs[1]}", t0=0, phase=2.1),
-        ]
 
     def _generate_calibration_defaults(self) -> PulseDefaults:
         """Generate pulse calibration defaults as specified with `self._calibrate_instructions`.
@@ -340,22 +362,31 @@ class GenericBackendV2(BackendV2):
         """
         # the qubit properties are sampled from default ranges
         properties = _QUBIT_PROPERTIES
-        self._target = Target(
-            description=f"Generic Target with {self._num_qubits} qubits",
-            num_qubits=self._num_qubits,
-            dt=properties["dt"],
-            qubit_properties=[
-                QubitProperties(
-                    t1=self._rng.uniform(properties["t1"][0], properties["t1"][1]),
-                    t2=self._rng.uniform(properties["t2"][0], properties["t2"][1]),
-                    frequency=self._rng.uniform(
-                        properties["frequency"][0], properties["frequency"][1]
-                    ),
-                )
-                for _ in range(self._num_qubits)
-            ],
-            concurrent_measurements=[list(range(self._num_qubits))],
-        )
+        if not self._noise_info:
+            self._target = Target(
+                description=f"Generic Target with {self._num_qubits} qubits",
+                num_qubits=self._num_qubits,
+                dt=properties["dt"],
+                qubit_properties=None,
+                concurrent_measurements=[list(range(self._num_qubits))],
+            )
+        else:
+            self._target = Target(
+                description=f"Generic Target with {self._num_qubits} qubits",
+                num_qubits=self._num_qubits,
+                dt=properties["dt"],
+                qubit_properties=[
+                    QubitProperties(
+                        t1=self._rng.uniform(properties["t1"][0], properties["t1"][1]),
+                        t2=self._rng.uniform(properties["t2"][0], properties["t2"][1]),
+                        frequency=self._rng.uniform(
+                            properties["frequency"][0], properties["frequency"][1]
+                        ),
+                    )
+                    for _ in range(self._num_qubits)
+                ],
+                concurrent_measurements=[list(range(self._num_qubits))],
+            )
 
         # Generate instruction schedule map with calibrations to add to target.
         calibration_inst_map = None
@@ -380,8 +411,13 @@ class GenericBackendV2(BackendV2):
                     f"Provided basis gate {name} needs more qubits than {self.num_qubits}, "
                     f"which is the size of the backend."
                 )
-            noise_params = self._get_noise_defaults(name, gate.num_qubits)
-            self._add_noisy_instruction_to_target(gate, noise_params, calibration_inst_map)
+            if self._noise_info:
+                noise_params = self._get_noise_defaults(name, gate.num_qubits)
+                self._add_noisy_instruction_to_target(gate, noise_params, calibration_inst_map)
+            else:
+                qarg_set = self._coupling_map if gate.num_qubits > 1 else range(self.num_qubits)
+                props = {(qarg,) if isinstance(qarg, int) else qarg: None for qarg in qarg_set}
+                self._target.add_instruction(gate, properties=props, name=name)
 
         if self._control_flow:
             self._target.add_instruction(IfElseOp, name="if_else")
@@ -501,8 +537,8 @@ class GenericBackendV2(BackendV2):
                     pulse_job = False
         if pulse_job is None:  # submitted job is invalid
             raise QiskitError(
-                "Invalid input object %s, must be either a "
-                "QuantumCircuit, Schedule, or a list of either" % circuits
+                f"Invalid input object {circuits}, must be either a "
+                "QuantumCircuit, Schedule, or a list of either"
             )
         if pulse_job:  # pulse job
             raise QiskitError("Pulse simulation is currently not supported for V2 backends.")
@@ -531,18 +567,12 @@ class GenericBackendV2(BackendV2):
 
     @classmethod
     def _default_options(cls) -> Options:
-        with warnings.catch_warnings():  # TODO remove catch once aer release without Provider ABC
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".+abstract Provider and ProviderV1.+",
-            )
-            if _optionals.HAS_AER:
-                from qiskit_aer import AerSimulator
+        if _optionals.HAS_AER:
+            from qiskit_aer import AerSimulator
 
-                return AerSimulator._default_options()
-            else:
-                return BasicSimulator._default_options()
+            return AerSimulator._default_options()
+        else:
+            return BasicSimulator._default_options()
 
     def drive_channel(self, qubit: int):
         drive_channels_map = getattr(self, "channels_map", {}).get("drive", {})

qiskit/providers/models/__init__.py

@@ -38,6 +38,7 @@ Classes
    GateProperties
    Nduv
 """
+import warnings
 
 from .backendconfiguration import (
     BackendConfiguration,
@@ -50,3 +51,13 @@ from .backendproperties import BackendProperties, GateProperties, Nduv
 from .backendstatus import BackendStatus
 from .jobstatus import JobStatus
 from .pulsedefaults import PulseDefaults, Command
+
+
+warnings.warn(
+    "qiskit.providers.models is deprecated since Qiskit 1.2 and will be removed in Qiskit 2.0."
+    "With the removal of Qobj, there is no need for these schema-conformant objects. If you still need"
+    "to use them, it could be because you are using a BackendV1, which is also deprecated in favor"
+    "of BackendV2",
+    DeprecationWarning,
+    2,
+)

qiskit/providers/models/backendconfiguration.py

@@ -26,6 +26,7 @@ from qiskit.pulse.channels import (
     DriveChannel,
     MeasureChannel,
 )
+from qiskit.utils import deprecate_func
 
 
 class GateConfig:
@@ -38,6 +39,15 @@ class GateConfig:
                   and CX.
     """
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` are part "
+        "of the deprecated `BackendV1` workflow  and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+        stacklevel=3,
+    )
     def __init__(
         self,
         name,
@@ -141,6 +151,14 @@ class UchannelLO:
         scale: Scale factor for qubit frequency.
     """
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` are part "
+        "of the deprecated `BackendV1` workflow  and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+    )
     def __init__(self, q, scale):
         """Initialize a UchannelLOSchema object
 
@@ -211,6 +229,15 @@ class QasmBackendConfiguration:
 
     _data = {}
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` are part "
+        "of the deprecated `BackendV1` workflow and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+        stacklevel=3,
+    )
     def __init__(
         self,
         backend_name,
@@ -491,9 +518,19 @@ class QasmBackendConfiguration:
 
 
 class BackendConfiguration(QasmBackendConfiguration):
-    """Backwards compat shim representing an abstract backend configuration."""
+    """Backwards compatibility shim representing an abstract backend configuration."""
 
-    pass
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` are part "
+        "of the deprecated `BackendV1` workflow and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+        stacklevel=3,
+    )
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
 
 class PulseBackendConfiguration(QasmBackendConfiguration):
@@ -501,6 +538,15 @@ class PulseBackendConfiguration(QasmBackendConfiguration):
     about the set up of the device which can be useful for building Pulse programs.
     """
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` are part "
+        "of the deprecated `BackendV1` workflow  and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+        stacklevel=3,
+    )
     def __init__(
         self,
         backend_name: str,
@@ -892,9 +938,9 @@ class PulseBackendConfiguration(QasmBackendConfiguration):
         channels = set()
         try:
             if isinstance(qubit, int):
-                for key in self._qubit_channel_map.keys():
+                for key, value in self._qubit_channel_map.items():
                     if qubit in key:
-                        channels.update(self._qubit_channel_map[key])
+                        channels.update(value)
                 if len(channels) == 0:
                     raise KeyError
             elif isinstance(qubit, list):

qiskit/providers/models/backendproperties.py

@@ -18,6 +18,7 @@ from typing import Any, Iterable, Tuple, Union, Dict
 import dateutil.parser
 
 from qiskit.providers.exceptions import BackendPropertyError
+from qiskit.utils import deprecate_func
 from qiskit.utils.units import apply_prefix
 
 PropertyT = Tuple[Any, datetime.datetime]
@@ -172,6 +173,15 @@ class BackendProperties:
 
     _data = {}
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="The models in ``qiskit.providers.models`` and related objects are part "
+        "of the deprecated `BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
+        "workflow requires these representations it likely relies on deprecated functionality and "
+        "should be updated to use `BackendV2`.",
+        stacklevel=3,
+    )
     def __init__(
         self, backend_name, backend_version, last_update_date, qubits, gates, general, **kwargs
     ):
@@ -248,6 +258,7 @@ class BackendProperties:
             qubits.append(nduvs)
         gates = [GateProperties.from_dict(x) for x in in_data.pop("gates")]
         general = [Nduv.from_dict(x) for x in in_data.pop("general")]
+
         return cls(
             backend_name, backend_version, last_update_date, qubits, gates, general, **in_data
         )
@@ -404,9 +415,9 @@ class BackendProperties:
             if name is not None:
                 result = result[name]
         except KeyError as ex:
+            formatted_name = "y '" + name + "'" if name else "ies"
             raise BackendPropertyError(
-                "Couldn't find the propert{name} for qubit "
-                "{qubit}.".format(name="y '" + name + "'" if name else "ies", qubit=qubit)
+                f"Couldn't find the propert{formatted_name} for qubit {qubit}."
             ) from ex
         return result
 

qiskit/providers/models/pulsedefaults.py

@@ -12,6 +12,7 @@
 
 
 """Model and schema for pulse defaults."""
+import warnings
 from typing import Any, Dict, List
 
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap, PulseQobjDef
@@ -271,7 +272,7 @@ class PulseDefaults:
             PulseDefaults: The PulseDefaults from the input dictionary.
         """
         schema = {
-            "pulse_library": PulseLibraryItem,
+            "pulse_library": PulseLibraryItem,  # The class PulseLibraryItem is deprecated
             "cmd_def": Command,
             "meas_kernel": MeasurementKernel,
             "discriminator": Discriminator,
@@ -282,10 +283,13 @@ class PulseDefaults:
         in_data = {}
         for key, value in data.items():
             if key in schema:
-                if isinstance(value, list):
-                    in_data[key] = list(map(schema[key].from_dict, value))
-                else:
-                    in_data[key] = schema[key].from_dict(value)
+                with warnings.catch_warnings():
+                    # The class PulseLibraryItem is deprecated
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    if isinstance(value, list):
+                        in_data[key] = list(map(schema[key].from_dict, value))
+                    else:
+                        in_data[key] = schema[key].from_dict(value)
             else:
                 in_data[key] = value
 
@@ -296,9 +300,4 @@ class PulseDefaults:
         meas_freqs = [freq / 1e9 for freq in self.meas_freq_est]
         qfreq = f"Qubit Frequencies [GHz]\n{qubit_freqs}"
         mfreq = f"Measurement Frequencies [GHz]\n{meas_freqs} "
-        return "<{name}({insts}{qfreq}\n{mfreq})>".format(
-            name=self.__class__.__name__,
-            insts=str(self.instruction_schedule_map),
-            qfreq=qfreq,
-            mfreq=mfreq,
-        )
+        return f"<{self.__class__.__name__}({str(self.instruction_schedule_map)}{qfreq}\n{mfreq})>"

qiskit/providers/options.py

@@ -116,7 +116,7 @@ class Options(Mapping):
     def __setitem__(self, key, value):
         self.update_options(**{key: value})
 
-    # backwards-compatibilty with Qiskit Experiments:
+    # backwards-compatibility with Qiskit Experiments:
 
     @property
     def __dict__(self):
@@ -154,7 +154,7 @@ class Options(Mapping):
 
         The returned option and validator values are shallow copies of the originals.
         """
-        out = self.__new__(type(self))
+        out = self.__new__(type(self))  # pylint:disable=no-value-for-parameter
         out.__setstate__((self._fields.copy(), self.validator.copy()))
         return out
 
@@ -170,7 +170,7 @@ class Options(Mapping):
 
     def __repr__(self):
         items = (f"{k}={v!r}" for k, v in self._fields.items())
-        return "{}({})".format(type(self).__name__, ", ".join(items))
+        return f"{type(self).__name__}({', '.join(items)})"
 
     def __eq__(self, other):
         if isinstance(self, Options) and isinstance(other, Options):
@@ -211,7 +211,7 @@ class Options(Mapping):
         """
 
         if field not in self._fields:
-            raise KeyError("Field '%s' is not present in this options object" % field)
+            raise KeyError(f"Field '{field}' is not present in this options object")
         if isinstance(validator_value, tuple):
             if len(validator_value) != 2:
                 raise ValueError(
@@ -229,28 +229,28 @@ class Options(Mapping):
                 f"{type(validator_value)} is not a valid validator type, it "
                 "must be a tuple, list, or class/type"
             )
-        self.validator[field] = validator_value
+        self.validator[field] = validator_value  # pylint: disable=unsupported-assignment-operation
 
     def update_options(self, **fields):
         """Update options with kwargs"""
-        for field in fields:
-            field_validator = self.validator.get(field, None)
+        for field_name, field in fields.items():
+            field_validator = self.validator.get(field_name, None)
             if isinstance(field_validator, tuple):
-                if fields[field] > field_validator[1] or fields[field] < field_validator[0]:
+                if field > field_validator[1] or field < field_validator[0]:
                     raise ValueError(
-                        f"Specified value for '{field}' is not a valid value, "
+                        f"Specified value for '{field_name}' is not a valid value, "
                         f"must be >={field_validator[0]} or <={field_validator[1]}"
                     )
             elif isinstance(field_validator, list):
-                if fields[field] not in field_validator:
+                if field not in field_validator:
                     raise ValueError(
-                        f"Specified value for {field} is not a valid choice, "
+                        f"Specified value for {field_name} is not a valid choice, "
                         f"must be one of {field_validator}"
                     )
             elif isinstance(field_validator, type):
-                if not isinstance(fields[field], field_validator):
+                if not isinstance(field, field_validator):
                     raise TypeError(
-                        f"Specified value for {field} is not of required type {field_validator}"
+                        f"Specified value for {field_name} is not of required type {field_validator}"
                     )
 
         self._fields.update(fields)

qiskit/providers/providerutils.py

@@ -21,7 +21,9 @@ from qiskit.providers.backend import Backend
 logger = logging.getLogger(__name__)
 
 
-def filter_backends(backends: list[Backend], filters: Callable = None, **kwargs) -> list[Backend]:
+def filter_backends(
+    backends: list[Backend], filters: Callable[[Backend], bool] | None = None, **kwargs
+) -> list[Backend]:
     """Return the backends matching the specified filtering.
 
     Filter the `backends` list by their `configuration` or `status`

qiskit/pulse/configuration.py

@@ -55,11 +55,9 @@ class Kernel:
         self.params = params
 
     def __repr__(self):
-        return "{}({}{})".format(
-            self.__class__.__name__,
-            "'" + self.name + "', " or "",
-            ", ".join(f"{str(k)}={str(v)}" for k, v in self.params.items()),
-        )
+        name_repr = "'" + self.name + "', "
+        params_repr = ", ".join(f"{str(k)}={str(v)}" for k, v in self.params.items())
+        return f"{self.__class__.__name__}({name_repr}{params_repr})"
 
     def __eq__(self, other):
         if isinstance(other, Kernel):
@@ -83,11 +81,9 @@ class Discriminator:
         self.params = params
 
     def __repr__(self):
-        return "{}({}{})".format(
-            self.__class__.__name__,
-            "'" + self.name + "', " or "",
-            ", ".join(f"{str(k)}={str(v)}" for k, v in self.params.items()),
-        )
+        name_repr = "'" + self.name + "', " or ""
+        params_repr = ", ".join(f"{str(k)}={str(v)}" for k, v in self.params.items())
+        return f"{self.__class__.__name__}({name_repr}{params_repr})"
 
     def __eq__(self, other):
         if isinstance(other, Discriminator):
@@ -184,7 +180,7 @@ class LoConfig:
             self.check_lo(channel, freq)
             self._m_lo_freq[channel] = freq
         else:
-            raise PulseError("Specified channel %s cannot be configured." % channel.name)
+            raise PulseError(f"Specified channel {channel.name} cannot be configured.")
 
     def add_lo_range(
         self, channel: DriveChannel | MeasureChannel, lo_range: LoRange | tuple[int, int]
@@ -236,7 +232,7 @@ class LoConfig:
             if channel in self.meas_los:
                 return self.meas_los[channel]
 
-        raise PulseError("Channel %s is not configured" % channel)
+        raise PulseError(f"Channel {channel} is not configured")
 
     @property
     def qubit_los(self) -> dict[DriveChannel, float]:

qiskit/pulse/instruction_schedule_map.py

@@ -169,10 +169,8 @@ class InstructionScheduleMap:
         if not self.has(instruction, _to_tuple(qubits)):
             if instruction in self._map:
                 raise PulseError(
-                    "Operation '{inst}' exists, but is only defined for qubits "
-                    "{qubits}.".format(
-                        inst=instruction, qubits=self.qubits_with_instruction(instruction)
-                    )
+                    f"Operation '{instruction}' exists, but is only defined for qubits "
+                    f"{self.qubits_with_instruction(instruction)}."
                 )
             raise PulseError(f"Operation '{instruction}' is not defined for this system.")
 
@@ -250,7 +248,7 @@ class InstructionScheduleMap:
 
         # validation of target qubit
         qubits = _to_tuple(qubits)
-        if qubits == ():
+        if not qubits:
             raise PulseError(f"Cannot add definition {instruction} with no target qubits.")
 
         # generate signature

qiskit/pulse/instructions/acquire.py

@@ -138,12 +138,11 @@ class Acquire(Instruction):
         return isinstance(self.duration, ParameterExpression) or super().is_parameterized()
 
     def __repr__(self) -> str:
-        return "{}({}{}{}{}{}{})".format(
-            self.__class__.__name__,
-            self.duration,
-            ", " + str(self.channel),
-            ", " + str(self.mem_slot) if self.mem_slot else "",
-            ", " + str(self.reg_slot) if self.reg_slot else "",
-            ", " + str(self.kernel) if self.kernel else "",
-            ", " + str(self.discriminator) if self.discriminator else "",
+        mem_slot_repr = str(self.mem_slot) if self.mem_slot else ""
+        reg_slot_repr = str(self.reg_slot) if self.reg_slot else ""
+        kernel_repr = str(self.kernel) if self.kernel else ""
+        discriminator_repr = str(self.discriminator) if self.discriminator else ""
+        return (
+            f"{self.__class__.__name__}({self.duration}, {str(self.channel)}, "
+            f"{mem_slot_repr}, {reg_slot_repr}, {kernel_repr}, {discriminator_repr})"
         )

qiskit/pulse/instructions/instruction.py

@@ -264,6 +264,5 @@ class Instruction(ABC):
 
     def __repr__(self) -> str:
         operands = ", ".join(str(op) for op in self.operands)
-        return "{}({}{})".format(
-            self.__class__.__name__, operands, f", name='{self.name}'" if self.name else ""
-        )
+        name_repr = f", name='{self.name}'" if self.name else ""
+        return f"{self.__class__.__name__}({operands}{name_repr})"

qiskit/pulse/library/samplers/decorators.py

@@ -182,9 +182,9 @@ def _update_docstring(discretized_pulse: Callable, sampler_inst: Callable) -> Ca
     header, body = wrapped_docstring.split("\n", 1)
     body = textwrap.indent(body, "                    ")
     wrapped_docstring = header + body
-    updated_ds = """
-                Discretized continuous pulse function: `{continuous_name}` using
-                sampler: `{sampler_name}`.
+    updated_ds = f"""
+                Discretized continuous pulse function: `{discretized_pulse.__name__}` using
+                sampler: `{sampler_inst.__name__}`.
 
                  The first argument (time) of the continuous pulse function has been replaced with
                  a discretized `duration` of type (int).
@@ -198,12 +198,8 @@ def _update_docstring(discretized_pulse: Callable, sampler_inst: Callable) -> Ca
 
                  Sampled continuous function:
 
-                    {continuous_doc}
-                """.format(
-        continuous_name=discretized_pulse.__name__,
-        sampler_name=sampler_inst.__name__,
-        continuous_doc=wrapped_docstring,
-    )
+                    {wrapped_docstring}
+                """
 
     discretized_pulse.__doc__ = updated_ds
     return discretized_pulse

qiskit/pulse/library/symbolic_pulses.py

@@ -570,11 +570,8 @@ class SymbolicPulse(Pulse):
 
     def __repr__(self) -> str:
         param_repr = ", ".join(f"{p}={v}" for p, v in self.parameters.items())
-        return "{}({}{})".format(
-            self._pulse_type,
-            param_repr,
-            f", name='{self.name}'" if self.name is not None else "",
-        )
+        name_repr = f", name='{self.name}'" if self.name is not None else ""
+        return f"{self._pulse_type}({param_repr}{name_repr})"
 
     __hash__ = None
 
@@ -677,8 +674,8 @@ class ScalableSymbolicPulse(SymbolicPulse):
             if not np.isclose(complex_amp1, complex_amp2):
                 return False
 
-        for key in self.parameters:
-            if key not in ["amp", "angle"] and self.parameters[key] != other.parameters[key]:
+        for key, value in self.parameters.items():
+            if key not in ["amp", "angle"] and value != other.parameters[key]:
                 return False
 
         return True