iqm-pulse 12.1.0__tar.gz → 12.2.0__tar.gz

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0}/CHANGELOG.rst

@@ -2,6 +2,17 @@
 Changelog
 =========
 
+Version 12.2.0 (2025-09-17)
+===========================
+
+Features
+--------
+
+- Improvements to Shelved_Measure_CustomWaveforms
+  - Calibration parameter `second_prx_12_offset` that allows performing the last pre_12 operation during the ReadoutTrigger (defaults to 0s -- i.e. perform the pulse immediately after the ReadoutTrigger)
+  - Shelved_Measure_CustomWaveforms.probe_timebox now allows multiplexing. The results from this method are multiplexable with the ones coming from the base class
+  - Shelved_Measure_CustomWaveforms.time_trace works
+
 Version 12.1.0 (2025-09-12)
 ===========================
 

{iqm_pulse-12.1.0/src/iqm_pulse.egg-info → iqm_pulse-12.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.1.0
+Version: 12.2.0
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0}/src/iqm/pulse/gate_implementation.py

@@ -516,6 +516,9 @@ class CustomIQWaveforms(GateImplementation):
                     if k not in cls.excluded_parameters
                 }
                 cls.parameters = root_parameters | {"i": parameters_i, "q": parameters_q}
+        # allow Mixins of CustomIQWaveforms and CompositeGate
+        if issubclass(cls, CompositeGate):
+            init_subclass_composite(cls)
 
 
 def get_waveform_parameters(wave: type[Waveform], label_prefix: str = "") -> dict[str, Setting | Parameter]:
@@ -599,6 +602,20 @@ class SinglePulseGate(GateImplementation):
         return self.builder.channels[self.channel].duration_to_seconds(self.pulse.duration)
 
 
+def init_subclass_composite(gate_class: type[CompositeGate]) -> None:
+    if not gate_class.registered_gates:
+        # this would be pointless
+        raise ValueError(f"CompositeGate {gate_class.__name__} has no registered gates.")
+    # TODO we should also check that customizable_gates may_have_calibration (otherwise it's pointless
+    # to call them customizable), but we don't currently have access to their implementation classes here...
+    if gate_class.customizable_gates is None:
+        gate_class.customizable_gates = gate_class.registered_gates
+    elif not set(gate_class.customizable_gates) <= set(gate_class.registered_gates):
+        raise ValueError(
+            f"CompositeGate {gate_class.__name__}: customizable_gates must be a subset of registered_gates."
+        )
+
+
 class CompositeGate(GateImplementation):
     """Base class for gate implementations that are defined in terms of other gate implementations.
 
@@ -649,15 +666,7 @@ class CompositeGate(GateImplementation):
     """
 
     def __init_subclass__(cls):
-        if not cls.registered_gates:
-            # this would be pointless
-            raise ValueError(f"CompositeGate {cls.__name__} has no registered gates.")
-        # TODO we should also check that customizable_gates may_have_calibration (otherwise it's pointless
-        # to call them customizable), but we don't currently have access to their implementation classes here...
-        if cls.customizable_gates is None:
-            cls.customizable_gates = cls.registered_gates
-        elif not set(cls.customizable_gates) <= set(cls.registered_gates):
-            raise ValueError(f"CompositeGate {cls.__name__}: customizable_gates must be a subset of registered_gates.")
+        init_subclass_composite(cls)
 
     @classmethod
     def optional_calibration_keys(cls) -> tuple[str, ...]:

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0}/src/iqm/pulse/gates/cz.py

@@ -29,7 +29,14 @@ import numpy as np
 
 from exa.common.data.parameter import Parameter, Setting
 from exa.common.qcm_data.chip_topology import DEFAULT_2QB_MAPPING
-from iqm.pulse.gate_implementation import GateImplementation, Locus, OILCalibrationData, get_waveform_parameters
+from iqm.pulse.gate_implementation import (
+    CompositeGate,
+    GateImplementation,
+    Locus,
+    OILCalibrationData,
+    get_waveform_parameters,
+    init_subclass_composite,
+)
 from iqm.pulse.playlist.instructions import Block, FluxPulse, Instruction, IQPulse, VirtualRZ
 from iqm.pulse.playlist.schedule import Schedule
 from iqm.pulse.playlist.waveforms import (
@@ -200,6 +207,8 @@ class FluxPulseGate(GateImplementation):
             parameters["qubit"]["amplitude"] = Parameter("", "Qubit flux pulse amplitude", "")
 
         cls.parameters = root_parameters | {k: v for k, v in parameters.items() if k not in cls.excluded_parameters}
+        if issubclass(cls, CompositeGate):
+            init_subclass_composite(cls)
 
     def _call(self) -> TimeBox:
         timebox = self.to_timebox(self._schedule)

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0}/src/iqm/pulse/gates/measure.py

@@ -15,7 +15,8 @@ r"""Projective measurement in the Z basis."""
 
 from __future__ import annotations
 
-from copy import deepcopy
+from collections.abc import Iterable
+from copy import copy, deepcopy
 from dataclasses import replace
 import functools
 from typing import TYPE_CHECKING
@@ -26,6 +27,7 @@ from exa.common.data.parameter import CollectionType, DataType, Parameter, Setti
 from iqm.pulse.gate_implementation import (
     PROBE_LINES_LOCUS_MAPPING,
     SINGLE_COMPONENTS_WITH_READOUT_LOCUS_MAPPING,
+    CompositeGate,
     CustomIQWaveforms,
     Locus,
     OILCalibrationData,
@@ -33,6 +35,7 @@ from iqm.pulse.gate_implementation import (
 from iqm.pulse.playlist.channel import ProbeChannelProperties
 from iqm.pulse.playlist.instructions import (
     AcquisitionMethod,
+    Block,
     ComplexIntegration,
     IQPulse,
     MultiplexedIQPulse,
@@ -41,7 +44,7 @@ from iqm.pulse.playlist.instructions import (
     TimeTrace,
 )
 from iqm.pulse.playlist.waveforms import Constant, Samples
-from iqm.pulse.timebox import MultiplexedProbeTimeBox, TimeBox
+from iqm.pulse.timebox import MultiplexedProbeTimeBox, SchedulingStrategy, TimeBox
 
 if TYPE_CHECKING:  # pragma: no cover
     from iqm.pulse.builder import ScheduleBuilder
@@ -101,10 +104,13 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
     ):
         super().__init__(parent, name, locus, calibration_data, builder)
 
-        self._multiplexed_timeboxes: dict[tuple[str, str, bool], MultiplexedProbeTimeBox] = {}
+        self._multiplexed_timeboxes: dict[tuple[str, str, bool], TimeBox] = {}
         """Cache for :meth:`probe_timebox`."""
         self._time_traces: dict[tuple[str, float | None, float | None, str], TimeBox] = {}
         """Cache for :meth:`time_trace`."""
+        self._neighborhood_components: set[str] = set(self.locus) | set(
+            self.builder.chip_topology.component_to_probe_line[q] for q in self.locus
+        )
 
         if len(locus) == 1:
             # prepare the single-component measurement
@@ -220,9 +226,7 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
 
         return probe_pulse, acquisition_method
 
-    def probe_timebox(
-        self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, **kwargs
-    ) -> MultiplexedProbeTimeBox:
+    def probe_timebox(self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, **kwargs) -> TimeBox:
         """Returns a "naked" probe timebox that supports convenient multiplexing through
         ``MultiplexedProbeTimeBox.__add__``.
 
@@ -292,18 +296,12 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
                         label=f"{self.__class__.__name__} on {self.locus}",
                     )
             else:
-                # factorizability: use the sub-implementations
-                # _skip_override used for child classes build on `Measure_CustomWaveforms` to not call `.probe_timebox`
-                # from the parent class, but from this class instead.
-                # TODO remove, make probe_timebox private or something.
                 probe_timeboxes = [
-                    self.sub_implementations[c].probe_timebox(key, feedback_key, do_acquisition, _skip_override=True)  # type: ignore[attr-defined]
+                    self.sub_implementations[c].probe_timebox(key, feedback_key, do_acquisition)  # type: ignore[attr-defined]
                     for c in self.locus
                 ]
                 probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
-            probe_timebox.neighborhood_components[0] = set(
-                self.locus + (self.builder.chip_topology.component_to_probe_line[self.locus[0]],)
-            )
+            probe_timebox.neighborhood_components[0] = copy(self._neighborhood_components)
             if feedback_key:
                 # Block all the virtual channels from the probes involved in self.locus as we cannot know what AWG
                 # might be listening to the sent bits. NOTE: No Waits are added, the channels are just blocked in
@@ -352,6 +350,11 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
         final_box.neighborhood_components[0] = final_box.children[0].neighborhood_components[0]
         return final_box
 
+    def _get_probe_timebox_for_time_trace(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Utility method that can be overridden in subclasses if they have a return type `.probe_pulse`."""
+        # FIXME: not needed once we align the return types of all these measure gates
+        return self.probe_timebox(key=key, feedback_key=feedback_key)
+
     def time_trace(
         self,
         key: str = "",
@@ -385,12 +388,16 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
         args = (key, acquisition_delay, acquisition_duration, feedback_key)
         # additional caching for time traces since the acquisitions differ from the ones in _call
         if args not in self._time_traces:
-            probe_timebox = deepcopy(self.probe_timebox(key=key, feedback_key=feedback_key, _skip_override=True))
+            probe_timebox = deepcopy(self._get_probe_timebox_for_time_trace(key, feedback_key))
             for probe_channel, segment in probe_timebox.atom.items():  # type: ignore[union-attr]
-                readout_trigger = segment[0]
+                readout_trigger = None
+                for inst in segment:
+                    if isinstance(inst, ReadoutTrigger):
+                        readout_trigger = inst
+                        break
                 # TODO instead of editing the probe_timebox output contents, we should make the function itself do this
                 # so we would not need to blindly search through the channels
-                if not isinstance(readout_trigger, ReadoutTrigger):
+                if readout_trigger is None:
                     continue
 
                 probe_line = self.builder.channels[probe_channel]
@@ -807,62 +814,181 @@ class Probe_Constant(ProbePulse_CustomWaveforms_noIntegration, wave_i=Constant,
     """
 
 
-class Shelved_Measure_CustomWaveforms(Measure_CustomWaveforms):
+class ShelvedMeasureTimeBox(TimeBox):
+    """TimeBox representing a shelved measurement (ReadoutTrigger sandwiched between two PRX_12 operations).
+
+    ShelvedMeasureTimeBox is a composite TimeBox containing two children:
+    * first one being the first PRX_12 operation for the locus components of the measure
+    * second one being the ReadoutTrigger (MultiplexedProbeTimeBox) that includes the second PRX_12 operation.
+
+    Multiplexing is achieved so that ShelvedMeasureTimeBoxes support ``__add__`` and ``__radd__`` operations with other
+    boxes of the same type and MultiplexedProbeTimeBoxes. The multiplexing operation is defined such that the
+    initial PRX_12 boxes are added together (in case one of the multiplexed boxes is a MultiplexedProbeTimeBoxes, the
+    initial PRX_12 is considered empty), and the probe boxes are multiplexed together via the logic defined in
+    ``MultiplexedProbeTimeBoxes.__add__``. This behaviour results in the correct timings of the associated pulses
+    after the multiplexing.
+
+    """
+
+    def __post_init__(self):
+        if len(self.children) != 2:
+            raise ValueError(
+                "ShelvedMeasureTimeBox must have exactly two children: the first one corresponding to the "
+                "initial prx_12 operations, and the second one to the ReadoutTrigger and the final prx_12"
+            )
+        if self.children[1].atom is None or not isinstance(self.children[1], MultiplexedProbeTimeBox):
+            raise ValueError("The second child must be an atomic MultiplexedProbeTimeBox.")
+
+    @property
+    def prx_12_box(self) -> TimeBox:
+        return self.children[0]
+
+    @property
+    def trigger_box(self) -> TimeBox:
+        return self.children[1]
+
+    def __add__(self, other: TimeBox | Iterable[TimeBox]) -> TimeBox:
+        """Add the initial PRX_12 boxes together via the ``TimeBox``"""
+        if isinstance(other, (ShelvedMeasureTimeBox, MultiplexedProbeTimeBox)):
+            if isinstance(other, ShelvedMeasureTimeBox):
+                prx_12_box = self.prx_12_box + other.prx_12_box
+                trigger_box = self.trigger_box + other.trigger_box
+            else:
+                prx_12_box = self.prx_12_box
+                trigger_box = self.trigger_box + other
+            locus_components = self.locus_components.union(other.locus_components)
+            multiplexed = ShelvedMeasureTimeBox(
+                label=f"Shelved measure on {locus_components}",
+                locus_components=locus_components,
+                atom=None,
+                children=(prx_12_box, trigger_box),
+                scheduling=self.scheduling,
+                scheduling_algorithm=self.scheduling_algorithm,
+            )
+            # neighborhood components by the trigger_box
+            multiplexed.neighborhood_components[0] = trigger_box.neighborhood_components[0]
+            return multiplexed
+        return super().__add__(other)
+
+    def __radd__(self, other: TimeBox | Iterable[TimeBox]) -> TimeBox:
+        return self.__add__(other)
+
+
+SHELVED_OFFSET_TOLERANCE = 1e-12
+"""Tolerance for the absolute value of shelved measure ``second_prx_12_offset`` calibration value 
+being considered zero."""
+
+
+class Shelved_Measure_CustomWaveforms(Measure_CustomWaveforms, CompositeGate):
     """Base class for shelved readout.
 
     Shelved readout applies a ``prx_12(pi)`` gate before and after a standard dispersive readout on each qubit measured.
     The first ``prx_12(pi)`` swaps the amplitudes of the |1> and |2> states, and the second one swaps them back after
-    the measurement has (roughtly) collapsed the state. If the discriminator of the readout is calibrated such that
+    the measurement has (roughly) collapsed the state. If the discriminator of the readout is calibrated such that
     the |0> state is on one side and the |1> and |2> states are on the other, the end result is equivalent to the
     standard readout operation but with the advantage that the population in the |2> state is less susceptible to
     :math:`T_1` decay during the readout than the population in the |1> state.
 
-    .. note:: Mixed implementation multiplexing is not supported.
     """
 
-    # Copied from `CompositeGate` to refresh caching after any calibration changes (in particular for the `prx_12`
-    # calibration)
-    def __call__(self, *args, **kwargs):
-        default_cache_key = tuple(args) + tuple(kwargs.items())
-        try:
-            hash(default_cache_key)
-            key_is_hashable = True
-        except TypeError:
-            key_is_hashable = False
-        if key_is_hashable:
-            if box := self.builder.composite_cache.get(self, default_cache_key):
-                return box
-        box = self._call(*args, **kwargs)
-        if key_is_hashable:
-            self.builder.composite_cache.set(self, default_cache_key, box)
-        return box
-
-    # `probe_timebox` is needed for making certain experiments work (e.g. `MeasurementQNDness`), since they call this
-    # function explicitly. However, the main functionality of this method will not work: Enabling mixed
-    # implementation multiplexing. This is because the method has to return time boxes due to the `prx_12` pulses,
-    # instead of `MultiplexedProbeTimeBox`
-    # TODO: Enable mixed implementation multiplexing for shelved readout
-    def probe_timebox(  # type: ignore[override]
-        self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, _skip_override: bool = False
-    ) -> TimeBox:
-        if _skip_override:
-            return super().probe_timebox(key, feedback_key, do_acquisition)
-        multiplexed_timeboxes = super().probe_timebox(key, feedback_key)
-        prx_12_impl = [self.builder.get_implementation("prx_12", [q])(np.pi) for q in self.locus]
-
-        boxes = prx_12_impl + multiplexed_timeboxes + prx_12_impl  # type: ignore[operator]
-        return boxes
-
-    def _call(self, key: str = "", feedback_key: str = "") -> TimeBox:  # type: ignore[override]
-        shelved_measure_box = TimeBox.composite(
-            self.probe_timebox(key=key, feedback_key=feedback_key),  # type: ignore[arg-type]
-            label=f"Readout on {self.locus}",
-        )
-        shelved_measure_box.neighborhood_components[0] = shelved_measure_box.children[
-            len(self.locus)
-        ].neighborhood_components[0]
+    root_parameters = Measure_CustomWaveforms.root_parameters | {
+        "second_prx_12_offset": Setting(
+            Parameter(
+                "second_prx_12_offset", "Offset of the second PRX_12 pulse from the end the ReadoutTrigger", unit="s"
+            ),
+            0.0,
+        ),
+        "do_prx_12": Setting(
+            Parameter(
+                "do_prx_12",
+                "Whether to do the prx_12 flips in the measure operation",
+                unit="",
+                data_type=DataType.BOOLEAN,
+            ),
+            True,
+        ),
+    }
+    registered_gates = ("prx_12",)
 
-        return shelved_measure_box
+    def probe_timebox(self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, **kwargs) -> TimeBox:  # type: ignore[union-attr, override]
+        """Returns a "naked" probe timebox that supports convenient multiplexing through
+        ``ShelvedMeasureTimeBox.__add__``.
+
+        This method can be used if the user wants to control the multiplexing explicitly. Supports adding together
+        boxes of type :class:`.ShelvedMeasureTimeBox` and/or :class:`.MultiplexedProbeTimeBox`. See
+        :meth:`.ShelvedMeasureTimeBox.__add__` for more information on the logic.
+
+        Args:
+            key: The readout results generated on this trigger will be assigned to
+                ``f"{qubit}__{key}"``, where ``qubit`` goes over the component names in ``self.locus``. If empty,
+                the key `"readout.result"` will be used to maintain backwards compatibility.
+            feedback_key: The signals generated by this measure operation are routed using this key for
+                fast feedback purposes. See :meth:`__call__`.
+            do_acquisition: if False, no acquisitions are added.
+
+        Returns:
+            ShelvedMeasureTimeBox containing the ReadoutTrigger instruction.
+
+        """
+        args = (key, feedback_key, do_acquisition)
+        if args not in self._multiplexed_timeboxes:
+            if len(self.locus) == 1:
+                probe_timebox = super().probe_timebox(key, feedback_key, do_acquisition, **kwargs)
+                shelved_box = probe_timebox
+                prx_12_box = TimeBox.composite(
+                    [self.build("prx_12", self.locus)(np.pi)], scheduling=SchedulingStrategy.ALAP
+                )
+                if self.calibration_data["do_prx_12"]:
+                    shelved_box = probe_timebox + prx_12_box  # type: ignore[operator, assignment, override]
+                # schedule the shelved box to get an atomic schedule
+                shelved_atom = deepcopy(self.builder.resolve_timebox(shelved_box, neighborhood=0))
+                offset = self.calibration_data["second_prx_12_offset"]
+                if self.calibration_data["do_prx_12"] and abs(offset) > SHELVED_OFFSET_TOLERANCE:
+                    drive_channel_name = self.builder.get_drive_channel(self.locus[0])
+                    drive_channel = self.builder.channels[drive_channel_name]
+                    offset_sign = offset / abs(offset)
+                    offset_in_samples = offset_sign * drive_channel.duration_to_int_samples(abs(offset))
+                    trigger_block = shelved_atom[drive_channel_name][0]
+                    block_with_offset = Block(trigger_block.duration + offset_in_samples)
+                    shelved_atom[drive_channel_name]._instructions[0] = block_with_offset
+                trigger_box = MultiplexedProbeTimeBox(
+                    label=f"{self.__class__.__name__} on {self.locus}",
+                    locus_components=probe_timebox.locus_components,
+                    atom=shelved_atom,
+                )
+                trigger_box.neighborhood_components[0] = probe_timebox.neighborhood_components[0]
+                pre_box = prx_12_box if self.calibration_data["do_prx_12"] else TimeBox.composite([])
+                final_box = ShelvedMeasureTimeBox(
+                    label=f"Shelved Measure on {self.locus}",
+                    locus_components=set(self.locus),
+                    atom=None,
+                    children=(pre_box, trigger_box),
+                )
+                final_box.neighborhood_components[0] = probe_timebox.neighborhood_components[0]
+            else:
+                # NOTE: the super call can be a bit misleading; it is actually calling the `self.probe_timebox` of len 1
+                # in this class inside, via the factorizable gate's sub_implementations
+                final_box = super().probe_timebox(key, feedback_key)  # type: ignore[assignment]
+            self._multiplexed_timeboxes[args] = final_box
+        return self._multiplexed_timeboxes[args]
+
+    def _get_probe_timebox_for_time_trace(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Utility method that can be overridden in subclasses if they have a return type `.probe_pulse`.
+
+        The ``ShelvedMeasureTimeBox`` resulting from :meth:`.probe_timebox` is first scheduled to obtain an atomic
+        ``MultiplexedProbeTimeBox`` which is wrapped into a TimeBox.
+        """
+        # FIXME: not needed once we align the return types of all these measure gates
+        probe_timebox = self.probe_timebox(key=key, feedback_key=feedback_key)
+        # resolve the box to get an atomic time_box.
+        probe_schedule = self.builder.resolve_timebox(probe_timebox, neighborhood=0)
+        atomic_probe_box = MultiplexedProbeTimeBox.atomic(
+            probe_schedule,
+            label=f"Time Trace atomic probe box of {self.__class__.__name__} on {self.locus}",
+            locus_components=probe_timebox.locus_components,
+        )
+        atomic_probe_box.neighborhood_components[0] = probe_timebox.neighborhood_components[0]
+        return atomic_probe_box
 
 
 class Shelved_Measure_Constant(Shelved_Measure_CustomWaveforms, wave_i=Constant, wave_q=Constant):  # type:ignore[call-arg]

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0}/src/iqm/pulse/timebox.py

@@ -23,7 +23,7 @@ import enum
 from functools import reduce
 
 from iqm.pulse.playlist.instructions import Block, ReadoutTrigger
-from iqm.pulse.playlist.schedule import Schedule
+from iqm.pulse.playlist.schedule import Schedule, Segment
 
 
 class SchedulingAlgorithm(enum.Enum):
@@ -164,8 +164,8 @@ class TimeBox:
             scheduling_algorithm=scheduling_algorithm,
         )
 
-    @staticmethod
-    def atomic(schedule: Schedule, *, locus_components: Iterable[str], label: str) -> TimeBox:
+    @classmethod
+    def atomic(cls, schedule: Schedule, *, locus_components: Iterable[str], label: str) -> TimeBox:
         """Build an atomic timebox from a schedule.
 
         Args:
@@ -177,7 +177,7 @@ class TimeBox:
             atomic timebox containing ``schedule``
 
         """
-        return TimeBox(label=label, locus_components=set(locus_components), atom=schedule, children=())
+        return cls(label=label, locus_components=set(locus_components), atom=schedule, children=())
 
     def validate(self, path: tuple[str, ...] = ()) -> None:
         """Validate the contents of the TimeBox.
@@ -227,6 +227,9 @@ class TimeBox:
             A new instance containing the children of both boxes.
 
         """
+        if issubclass(type(other), TimeBox) and type(other) is not TimeBox:  # strict subclass
+            # allow subclasses to override __add__ such that __radd__ also works consistent with that logic
+            return other.__radd__(self)  # type: ignore[union-attr]
         if isinstance(other, TimeBox):
             left = self.children if self.atom is None else (self,)
             right = other.children if other.atom is None else (other,)
@@ -243,7 +246,9 @@ class TimeBox:
         except TypeError as err:
             raise TypeError(f"Cannot add a TimeBox and a {type(other)}.") from err
 
-    def __radd__(self, other: Iterable[TimeBox]) -> TimeBox:
+    def __radd__(self, other: TimeBox | Iterable[TimeBox]) -> TimeBox:
+        if isinstance(other, TimeBox):
+            return self.__add__(other)
         it = iter(other)
         try:
             first = next(it)
@@ -312,21 +317,25 @@ class MultiplexedProbeTimeBox(TimeBox):
     A ``MultiplexedProbeTimeBox``'s atom contains exactly one ``ReadoutTrigger`` for each probe channel.
     """
 
+    def _multiplex(self, other_atom: Schedule) -> dict[str, Segment]:
+        new_segments = dict(self.atom.copy().items())  # type: ignore[union-attr]
+        for channel, segment in other_atom.items():
+            if channel not in new_segments:
+                new_segments[channel] = segment
+            elif isinstance(segment[0], ReadoutTrigger) and isinstance(new_segments[channel][0], ReadoutTrigger):
+                # multiplex the readout triggers together
+                new_segments[channel]._instructions[0] = new_segments[channel][0] + segment[0]
+            else:
+                new_segments[channel].extend(iter(segment))
+        return new_segments
+
     def __add__(self, other: TimeBox | Iterable[TimeBox]) -> TimeBox:
         """Override ``__add__`` for two atomic ``MultiplexedProbeTimeBox`` instances such that ``ReadoutTrigger``s
         belonging to the same probe channel are multiplexed together. Otherwise, behaves exactly like
         ``TimeBox.__add__``, returning a normal ``TimeBox``.
         """
         if isinstance(other, MultiplexedProbeTimeBox) and self.atom is not None and other.atom is not None:
-            new_segments = dict(self.atom.copy().items())
-            for channel, segment in other.atom.items():
-                if channel not in new_segments:
-                    new_segments[channel] = segment
-                elif isinstance(segment[0], ReadoutTrigger) and isinstance(new_segments[channel][0], ReadoutTrigger):
-                    # multiplex the readout triggers together
-                    new_segments[channel]._instructions[0] = new_segments[channel][0] + segment[0]
-                else:
-                    new_segments[channel].extend(iter(segment))
+            new_segments = self._multiplex(other.atom)
             locus_components = self.locus_components.union(other.locus_components)
             max_nb = max(
                 max(self.neighborhood_components, default=-1),
@@ -341,7 +350,7 @@ class MultiplexedProbeTimeBox(TimeBox):
                     neighborhood_components[nb] = self.neighborhood_components[nb].union(
                         other.neighborhood_components[nb]
                     )
-            return MultiplexedProbeTimeBox(
+            return type(self)(
                 label=f"MultiplexedProbeTimeBox on {locus_components}",
                 locus_components=locus_components,
                 atom=Schedule(new_segments),
@@ -388,3 +397,6 @@ class MultiplexedProbeTimeBox(TimeBox):
             scheduling_algorithm=SchedulingAlgorithm.HARD_BOUNDARY,
         )
         return box
+
+    def __radd__(self, other: TimeBox | Iterable[TimeBox]) -> TimeBox:
+        return self.__add__(other)

{iqm_pulse-12.1.0 → iqm_pulse-12.2.0/src/iqm_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.1.0
+Version: 12.2.0
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License

iqm_pulse-12.2.0/version.txt

@@ -0,0 +1 @@
+12.2.0

iqm_pulse-12.1.0/version.txt

@@ -1 +0,0 @@
-12.1.0