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

qiskit/providers/models/__init__.py

@@ -38,15 +38,52 @@ Classes
    GateProperties
    Nduv
 """
+# pylint: disable=undefined-all-variable
+__all__ = [
+    "BackendConfiguration",
+    "PulseBackendConfiguration",
+    "QasmBackendConfiguration",
+    "UchannelLO",
+    "GateConfig",
+    "BackendProperties",
+    "GateProperties",
+    "Nduv",
+    "BackendStatus",
+    "JobStatus",
+    "PulseDefaults",
+    "Command",
+]
 
-from .backendconfiguration import (
-    BackendConfiguration,
-    PulseBackendConfiguration,
-    QasmBackendConfiguration,
-    UchannelLO,
-    GateConfig,
-)
-from .backendproperties import BackendProperties, GateProperties, Nduv
-from .backendstatus import BackendStatus
-from .jobstatus import JobStatus
-from .pulsedefaults import PulseDefaults, Command
+import importlib
+import warnings
+
+
+_NAME_MAP = {
+    # public object name mapped to containing module
+    "BackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "PulseBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "QasmBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "UchannelLO": "qiskit.providers.models.backendconfiguration",
+    "GateConfig": "qiskit.providers.models.backendconfiguration",
+    "BackendProperties": "qiskit.providers.models.backendproperties",
+    "GateProperties": "qiskit.providers.models.backendproperties",
+    "Nduv": "qiskit.providers.models.backendproperties",
+    "BackendStatus": "qiskit.providers.models.backendstatus",
+    "JobStatus": "qiskit.providers.models.jobstatus",
+    "PulseDefaults": "qiskit.providers.models.pulsedefaults",
+    "Command": "qiskit.providers.models.pulsedefaults",
+}
+
+
+def __getattr__(name):
+    if (module_name := _NAME_MAP.get(name)) is not None:
+        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,
+            stacklevel=2,
+        )
+        return getattr(importlib.import_module(module_name), name)
+    raise AttributeError(f"module 'qiskit.providers.models' has no attribute '{name}'")

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

qiskit/pulse/library/waveform.py

@@ -130,8 +130,5 @@ class Waveform(Pulse):
         opt = np.get_printoptions()
         np.set_printoptions(threshold=50)
         np.set_printoptions(**opt)
-        return "{}({}{})".format(
-            self.__class__.__name__,
-            repr(self.samples),
-            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.__class__.__name__}({repr(self.samples)}{name_repr})"

qiskit/pulse/macros.py

@@ -124,16 +124,21 @@ def _measure_v1(
     for qubit in qubits:
         measure_groups.add(tuple(meas_map[qubit]))
     for measure_group_qubits in measure_groups:
-        if qubit_mem_slots is not None:
-            unused_mem_slots = set(measure_group_qubits) - set(qubit_mem_slots.values())
+
+        unused_mem_slots = (
+            set()
+            if qubit_mem_slots is None
+            else set(measure_group_qubits) - set(qubit_mem_slots.values())
+        )
+
         try:
             default_sched = inst_map.get(measure_name, measure_group_qubits)
         except exceptions.PulseError as ex:
             raise exceptions.PulseError(
-                "We could not find a default measurement schedule called '{}'. "
+                f"We could not find a default measurement schedule called '{measure_name}'. "
                 "Please provide another name using the 'measure_name' keyword "
                 "argument. For assistance, the instructions which are defined are: "
-                "{}".format(measure_name, inst_map.instructions)
+                f"{inst_map.instructions}"
             ) from ex
         for time, inst in default_sched.instructions:
             if inst.channel.index not in qubits:
@@ -198,10 +203,10 @@ def _measure_v2(
                 schedule += _schedule_remapping_memory_slot(default_sched, qubit_mem_slots)
         except KeyError as ex:
             raise exceptions.PulseError(
-                "We could not find a default measurement schedule called '{}'. "
+                f"We could not find a default measurement schedule called '{measure_name}'. "
                 "Please provide another name using the 'measure_name' keyword "
                 "argument. For assistance, the instructions which are defined are: "
-                "{}".format(measure_name, target.instructions)
+                f"{target.instructions}"
             ) from ex
     return schedule
 

qiskit/pulse/parser.py

@@ -120,17 +120,15 @@ class PulseExpression(ast.NodeTransformer):
         if kwargs:
             for key, val in kwargs.items():
                 if key in self.params:
-                    if key not in self._locals_dict.keys():
+                    if key not in self._locals_dict:
                         self._locals_dict[key] = val
                     else:
                         raise PulseError(
-                            "%s got multiple values for argument '%s'"
-                            % (self.__class__.__name__, key)
+                            f"{self.__class__.__name__} got multiple values for argument '{key}'"
                         )
                 else:
                     raise PulseError(
-                        "%s got an unexpected keyword argument '%s'"
-                        % (self.__class__.__name__, key)
+                        f"{self.__class__.__name__} got an unexpected keyword argument '{key}'"
                     )
 
         expr = self.visit(self._tree)
@@ -139,7 +137,7 @@ class PulseExpression(ast.NodeTransformer):
             if self._partial_binding:
                 return PulseExpression(expr, self._partial_binding)
             else:
-                raise PulseError("Parameters %s are not all bound." % self.params)
+                raise PulseError(f"Parameters {self.params} are not all bound.")
         return expr.body.value
 
     @staticmethod
@@ -160,7 +158,7 @@ class PulseExpression(ast.NodeTransformer):
         for op_type, op_func in opr_dict.items():
             if isinstance(opr, op_type):
                 return op_func(*args)
-        raise PulseError("Operator %s is not supported." % opr.__class__.__name__)
+        raise PulseError(f"Operator {opr.__class__.__name__} is not supported.")
 
     def visit_Expression(self, node: ast.Expression) -> ast.Expression:
         """Evaluate children nodes of expression.
@@ -272,8 +270,8 @@ class PulseExpression(ast.NodeTransformer):
         node = copy.copy(node)
         node.args = [self.visit(arg) for arg in node.args]
         if all(isinstance(arg, ast.Constant) for arg in node.args):
-            if node.func.id not in self._math_ops.keys():
-                raise PulseError("Function %s is not supported." % node.func.id)
+            if node.func.id not in self._math_ops:
+                raise PulseError(f"Function {node.func.id} is not supported.")
             _args = [arg.value for arg in node.args]
             _val = self._math_ops[node.func.id](*_args)
             if not _val.imag:
@@ -283,7 +281,7 @@ class PulseExpression(ast.NodeTransformer):
         return node
 
     def generic_visit(self, node):
-        raise PulseError("Unsupported node: %s" % node.__class__.__name__)
+        raise PulseError(f"Unsupported node: {node.__class__.__name__}")
 
 
 def parse_string_expr(source: str, partial_binding: bool = False) -> PulseExpression: