iqm-pulse 12.6.1__tar.gz → 12.7.1__tar.gz

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/CHANGELOG.rst

@@ -1,11 +1,29 @@
-=========
-Changelog
-=========
+Version 12.7.1 (2025-12-02)
+===========================
+
+Bug fixes
+---------
+
+- Fix version ranges in python package dependencies.
 
-Version 12.6.1 (2025-10-27)
+Version 12.7.0 (2025-11-19)
 ===========================
 
-- Bump version for 4.3.1 release. No functional changes.
+Features
+--------
+
+- Playlist generation now does acq discovery
+- Add ``Fast_Measure_CustomWaveForms`` and ``Fast_Measure_Constant`` measure implementations that block the locus qubit
+  drive and flux channels only for the duration of the physical probe pulse (plus additional calibratable dead time to
+  account for e.g. ring-down delay).
+- The implementation ``Fast_Measure_CustomWaveForms`` is simplified such that it no longer requires additional virtual
+  probe channels.
+
+Bug fixes
+---------
+
+- Fix `Fast_Measure_CustomWaveForms` not being scheduled correctly in some cases involving deep TimeBox structures.
+- Fix `Fast_Measure_CustomWaveForms.time_trace` which was broken.
 
 Version 12.6.0 (2025-10-23)
 ===========================
@@ -350,7 +368,7 @@ Version 8.13.0 (2025-04-07)
 Features
 --------
 
-- Fix package version in published docs footers, :issue:`SW-1392`. 
+- Fix package version in published docs footers, :issue:`SW-1392`.
 
 Version 8.12.0 (2025-04-03)
 ===========================
@@ -383,7 +401,7 @@ Version 8.9.0 (2025-03-28)
 Features
 --------
 
-- Reworked the way default gates (operations) are defined so they are decoupled from their implementations. This separation allows for the deletion of default implementations without losing information about its designated name. 
+- Reworked the way default gates (operations) are defined so they are decoupled from their implementations. This separation allows for the deletion of default implementations without losing information about its designated name.
 - The majority of the original functionality stays the same.
 - The ``register_implementation`` function has been split into several different functions to improve readability and testing, as seen below::
 
@@ -395,8 +413,8 @@ Features
                                                                                     v
                                                                           ``validate_implementation`` --> ``set_default``
 
-- The ``build_quantum_ops`` function in builder.py has been split into several functions as well. 
-- Trying to modify the implementation class of an existing or default gate implementation yields an error. 
+- The ``build_quantum_ops`` function in builder.py has been split into several functions as well.
+- Trying to modify the implementation class of an existing or default gate implementation yields an error.
 
 
 
@@ -1201,7 +1219,7 @@ Version 1.5 (2024-07-05)
 
 Features
 --------
-- Bump exa-common to 25.3 
+- Bump exa-common to 25.3
 
 
 Version 1.4 (2024-07-04)

iqm_pulse-12.7.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include version.txt
+include LICENSE.txt
+prune tests/*
+exclude .gitlab-ci.yml

{iqm_pulse-12.6.1/src/iqm_pulse.egg-info → iqm_pulse-12.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.6.1
+Version: 12.7.1
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License
@@ -204,7 +204,7 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-Project-URL: Documentation, https://iqm-finland.github.io/docs/iqm-pulse/
+Project-URL: Documentation, https://docs.meetiqm.com/iqm-pulse/
 Project-URL: Homepage, https://pypi.org/project/iqm-pulse/
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -213,7 +213,6 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: iqm-exa-common<28,>=27
 Requires-Dist: iqm-data-definitions<3.0,>=2.18
 Requires-Dist: python-rapidjson==1.20
 Requires-Dist: jinja2==3.0.3
@@ -226,7 +225,7 @@ IQM Pulse library
 
 A Python-based project for providing interface and implementations for control pulses.
 
-See `API documentation <https://iqm-finland.github.io/docs/iqm-pulse/>`_.
+See `API documentation <https://docs.meetiqm.com/iqm-pulse/>`_.
 
 Copyright
 ---------

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/README.rst

@@ -3,7 +3,7 @@ IQM Pulse library
 
 A Python-based project for providing interface and implementations for control pulses.
 
-See `API documentation <https://iqm-finland.github.io/docs/iqm-pulse/>`_.
+See `API documentation <https://docs.meetiqm.com/iqm-pulse/>`_.
 
 Copyright
 ---------

iqm_pulse-12.7.1/docs/changelog.rst

@@ -0,0 +1,8 @@
+.. _changelog:
+
+=========
+CHANGELOG
+=========
+
+.. include:: ../CHANGELOG.rst
+   :literal:

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/pyproject.toml

@@ -1,4 +1,3 @@
-# This file is managed by monotool.py, do not edit by hand
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [ "setuptools", "setuptools_scm[toml]",]
@@ -18,7 +17,7 @@ email = "info@meetiqm.com"
 file = "LICENSE.txt"
 
 [project.urls]
-Documentation = "https://iqm-finland.github.io/docs/iqm-pulse/"
+Documentation = "https://docs.meetiqm.com/iqm-pulse/"
 Homepage = "https://pypi.org/project/iqm-pulse/"
 
 [tool.mypy]
@@ -57,7 +56,7 @@ nb_diff_ignore = [ "/metadata/language_info", "/metadata/widgets", "/cells/*/exe
 
 [tool.ruff.lint]
 ignore = [ "D203", "D213",]
-select = [ "E4", "E7", "E9", "E5", "F", "Q", "PL", "I", "D", "UP007", "UP006", "UP035", "ANN001", "ANN201", "ANN202",]
+select = [ "E4", "E7", "E9", "E5", "F", "Q", "PL", "I", "D", "UP007", "UP006", "UP035", "ANN001", "ANN201", "ANN202", "NPY201",]
 unfixable = [ "F401",]
 
 [tool.ruff.lint.isort]
@@ -68,10 +67,10 @@ known-third-party = [ "exa", "iqm",]
 relative-imports-order = "closest-to-furthest"
 
 [tool.ruff.lint.per-file-ignores]
-"**/__init__.py" = [ "F401", "PLR0402",]
+"**/__init__.py" = [ "D104", "F401", "PLR0402",]
 "**/docs/*" = [ "E402", "D100",]
 "**/setup.py" = [ "D100", "D103", "I001", "ANN201",]
-"**/src/*" = [ "PLR2004", "D400", "D415", "D205", "D401", "D417", "D100", "D101", "D107", "D102", "D105", "D103", "D404", "D104",]
+"**/src/*" = [ "PLR2004", "D400", "D415", "D205", "D401", "D417", "D100", "D107", "D105", "D102", "D404",]
 "**/tests/*" = [ "F632", "PLR2004", "PLR0402", "PLC0414", "D", "ANN001", "ANN201", "ANN202",]
 
 [tool.ruff.lint.pylint]

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/requirements/base.txt

@@ -1,7 +1,7 @@
-iqm-exa-common>=27,<28
 iqm-data-definitions >= 2.18, < 3.0
 python-rapidjson == 1.20
 jinja2 == 3.0.3
 numpy >= 1.26.4,<3.0
 scipy >= 1.11.4,<1.16
-scipy-stubs
+scipy-stubs
+

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/builder.py

@@ -15,8 +15,7 @@
 
 from __future__ import annotations
 
-from collections import defaultdict
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 import copy
 from dataclasses import dataclass, field, replace
 import itertools
@@ -56,6 +55,7 @@ from iqm.pulse.playlist.instructions import (
     Instruction,
     IQPulse,
     MultiplexedIQPulse,
+    ReadoutMetrics,
     ReadoutTrigger,
     RealPulse,
     ThresholdStateDiscrimination,
@@ -492,6 +492,10 @@ class ScheduleBuilder:
         """Probe line channel for the probe line ``component`` belongs to.
 
         See :meth:`.get_drive_channel`.
+
+        Args:
+            component: name of a QPU component (typically qubit) to probe
+
         """
         probe_line = self.chip_topology.component_to_probe_line.get(component, None)
         if probe_line is None:
@@ -1038,7 +1042,7 @@ class ScheduleBuilder:
 
     def timeboxes_to_front_padded_playlist(
         self, boxes: Iterable[TimeBox], *, neighborhood: int = 0
-    ) -> tuple[Playlist, dict[str, set[str]]]:
+    ) -> tuple[Playlist, ReadoutMetrics]:
         """Temporary helper function, for converting a sequence of TimeBoxes to a Playlist.
 
         Each individual TimeBox in ``boxes`` is resolved into a Schedule, and then
@@ -1057,8 +1061,7 @@ class ScheduleBuilder:
                 blocks only the defined locus components and any other components which have occupied channels.
 
         Returns:
-            playlist that implements ``boxes`` and the mapping from readout labels to the set of used measurement
-            implementations (of the format ``<QuantumOp name>.<impl name>``).
+            playlist that implements ``boxes`` and the readout metrics for that playlist.
 
         """
         schedules = [self.resolve_timebox(box, neighborhood=neighborhood).cleanup() for box in boxes]
@@ -1102,7 +1105,7 @@ class ScheduleBuilder:
             playlist that implements ``boxes``
 
         """
-        return self.build_playlist(self.timebox_to_schedule(box, neighborhood=neighborhood) for box in boxes)[0]
+        return self.build_playlist([self.timebox_to_schedule(box, neighborhood=neighborhood) for box in boxes])[0]
 
     def timebox_to_schedule(
         self,
@@ -1453,8 +1456,8 @@ class ScheduleBuilder:
                 schedule.append(ch, Block(T))
 
     def build_playlist(  # noqa: PLR0915
-        self, schedules: Iterable[Schedule], finish_schedules: bool = True
-    ) -> tuple[Playlist, dict[str, set[str]]]:
+        self, schedules: Sequence[Schedule], finish_schedules: bool = True
+    ) -> tuple[Playlist, ReadoutMetrics]:
         """Build a playlist from a number of instruction schedules.
 
         This involves compressing the schedules so that no duplicate information
@@ -1468,8 +1471,7 @@ class ScheduleBuilder:
                 unless some process has already finalised them before calling this function.
 
         Returns:
-            playlist containing the schedules and the mapping from readout labels to the set of used measurement
-            implementations (of the format ``<QuantumOp name>.<impl name>``).
+            playlist containing the schedules and the readout metrics for this playlist.
 
         Raises:
             ValueError: if the schedules contain channels with non-uniform sampling rates
@@ -1492,6 +1494,7 @@ class ScheduleBuilder:
 
         pl = Playlist()
         mapped_instructions: dict[str, dict[int | Instruction, Any]] = {}
+        readout_metrics = ReadoutMetrics(num_segments=len(schedules))
 
         def _append_to_schedule(sc_schedule: SC_Schedule, channel_name: str, instr: Instruction) -> None:
             """Append ``instr`` to ``sc_schedule`` into the channel``channel_name``."""
@@ -1517,15 +1520,15 @@ class ScheduleBuilder:
 
                 # add the schedules in the playlist
 
-        label_to_implementation: dict[str, set[str]] = defaultdict(set)
-
         def _map_instruction(inst: Instruction) -> sc_instructions.Instruction:
             """TODO only necessary until SC has been updated to use the iqm.pulse Instruction class."""
             operation: Any
 
             def _map_acquisition(acq: AcquisitionMethod) -> sc_instructions.AcquisitionMethod:
-                if acq.implementation is not None:
-                    label_to_implementation[acq.label].add(acq.implementation)
+                if isinstance(acq, TimeTrace):
+                    return sc_instructions.TimeTrace(
+                        label=acq.label, delay_samples=acq.delay_samples, duration_samples=acq.duration_samples
+                    )
                 if isinstance(acq, ThresholdStateDiscrimination):
                     return sc_instructions.ThresholdStateDiscrimination(
                         label=acq.label,
@@ -1540,10 +1543,7 @@ class ScheduleBuilder:
                         delay_samples=acq.delay_samples,
                         weights=_map_instruction(acq.weights).operation,
                     )
-                if isinstance(acq, TimeTrace):
-                    return sc_instructions.TimeTrace(
-                        label=acq.label, delay_samples=acq.delay_samples, duration_samples=acq.duration_samples
-                    )
+
                 raise ValueError(f"Unknown AcquisitionMethod {acq}")
 
             if isinstance(inst, Wait):
@@ -1587,7 +1587,7 @@ class ScheduleBuilder:
             return sc_instructions.Instruction(duration_samples=int(inst.duration), operation=operation)
 
         # NOTE that there is no implicit right-alignment or equal duration for schedules, unlike in old-style playlists!
-        for schedule in schedules:
+        for seg_idx, schedule in enumerate(schedules):
             finished_schedule = self._finish_schedule(schedule) if finish_schedules else schedule
             sc_schedule = SC_Schedule()
             for channel_name, segment in finished_schedule.items():
@@ -1596,6 +1596,8 @@ class ScheduleBuilder:
                 pl.add_channel(channel)
                 prev_wait = None
                 for instruction in segment:
+                    if isinstance(instruction, ReadoutTrigger):
+                        readout_metrics.extend(instruction, seg_idx)
                     # convert all NONSOLID instructions into Waits
                     if finish_schedules and (isinstance(instruction, NONSOLID) or isinstance(instruction, Wait)):
                         if instruction.duration > 0:
@@ -1614,7 +1616,7 @@ class ScheduleBuilder:
                 if prev_wait:
                     _append_to_schedule(sc_schedule, channel_name, prev_wait)
             pl.segments.append(sc_schedule)
-        return pl, label_to_implementation
+        return pl, readout_metrics
 
     def _set_gate_implementation_shortcut(self, op_name: str) -> None:
         """Create shortcut for `self.get_implementation(<op_name>, ...)` as `self.<op_name>(...)`.

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/gate_implementation.py

@@ -602,7 +602,7 @@ class SinglePulseGate(GateImplementation):
         return self.builder.channels[self.channel].duration_to_seconds(self.pulse.duration)
 
 
-def init_subclass_composite(gate_class: type[CompositeGate]) -> None:
+def init_subclass_composite(gate_class: type[CompositeGate]) -> None:  # noqa: D103
     if not gate_class.registered_gates:
         # this would be pointless
         raise ValueError(f"CompositeGate {gate_class.__name__} has no registered gates.")

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/gates/__init__.py

@@ -49,7 +49,12 @@ from iqm.pulse.gates.cz import (
 from iqm.pulse.gates.default_gates import _implementation_library, _quantum_ops_library
 from iqm.pulse.gates.delay import Delay
 from iqm.pulse.gates.flux_multiplexer import FluxMultiplexer_SampleLinear
-from iqm.pulse.gates.measure import Measure_Constant, Measure_Constant_Qnd, Shelved_Measure_Constant
+from iqm.pulse.gates.measure import (
+    Fast_Measure_Constant,
+    Measure_Constant,
+    Measure_Constant_Qnd,
+    Shelved_Measure_Constant,
+)
 from iqm.pulse.gates.move import MOVE_CRF_CRF, MOVE_SLEPIAN_CRF, MOVE_TGSS_CRF
 from iqm.pulse.gates.prx import (
     Constant_PRX_with_smooth_rise_fall,
@@ -105,6 +110,7 @@ _exposed_implementations: dict[str, type[GateImplementation]] = {
         FluxPulseGate_CRF_CRF,
         Measure_Constant,
         Measure_Constant_Qnd,
+        Fast_Measure_Constant,
         Shelved_Measure_Constant,
         PRX_ModulatedDRAGCosineRiseFall,
         MOVE_CRF_CRF,

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/gates/default_gates.py

@@ -38,7 +38,11 @@ from iqm.pulse.gates.cz import (
 )
 from iqm.pulse.gates.delay import Delay
 from iqm.pulse.gates.flux_multiplexer import FluxMultiplexer_SampleLinear
-from iqm.pulse.gates.measure import Measure_Constant, Shelved_Measure_Constant
+from iqm.pulse.gates.measure import (
+    Fast_Measure_Constant,
+    Measure_Constant,
+    Shelved_Measure_Constant,
+)
 from iqm.pulse.gates.move import MOVE_CRF_CRF, MOVE_SLEPIAN_CRF, MOVE_TGSS_CRF
 from iqm.pulse.gates.prx import (
     PRX_DRAGCosineRiseFall,
@@ -68,6 +72,7 @@ _implementation_library: dict[str, dict[str, type[GateImplementation]]] = {
     "delay": {"wait": Delay},
     "measure": {
         "constant": Measure_Constant,
+        "fast_constant": Fast_Measure_Constant,
     },
     "measure_fidelity": {
         "constant": Measure_Constant,

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/gates/measure.py

@@ -32,6 +32,7 @@ from iqm.pulse.gate_implementation import (
     Locus,
     OILCalibrationData,
 )
+from iqm.pulse.playlist import Schedule, Segment
 from iqm.pulse.playlist.channel import ProbeChannelProperties
 from iqm.pulse.playlist.instructions import (
     AcquisitionMethod,
@@ -44,7 +45,7 @@ from iqm.pulse.playlist.instructions import (
     TimeTrace,
 )
 from iqm.pulse.playlist.waveforms import Constant, Samples
-from iqm.pulse.timebox import MultiplexedProbeTimeBox, SchedulingStrategy, TimeBox
+from iqm.pulse.timebox import MultiplexedProbeTimeBox, ProbeTimeBoxes, SchedulingStrategy, TimeBox
 
 if TYPE_CHECKING:  # pragma: no cover
     from iqm.pulse.builder import ScheduleBuilder
@@ -53,6 +54,7 @@ if TYPE_CHECKING:  # pragma: no cover
 DEFAULT_INTEGRATION_KEY = "readout.result"
 DEFAULT_TIME_TRACE_KEY = "readout.time_trace"
 FEEDBACK_KEY = "feedback"
+TIMING_TOLERANCE = 1e-12
 
 
 class Measure_CustomWaveforms(CustomIQWaveforms):
@@ -301,16 +303,17 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
                     for c in self.locus
                 ]
                 probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
-            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
-                # scheduling, so the impact to performance is negligible
-                probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
-                for probe in probelines:
-                    probe_timebox.neighborhood_components[0].update(
-                        set(self.builder.get_virtual_feedback_channels(probe))
-                    )
+            if isinstance(probe_timebox, TimeBox):  # FIXME: not needed once the measure implementations are cleaned up
+                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
+                    # scheduling, so the impact to performance is negligible
+                    probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
+                    for probe in probelines:
+                        probe_timebox.neighborhood_components[0].update(
+                            set(self.builder.get_virtual_feedback_channels(probe))
+                        )
             self._multiplexed_timeboxes[args] = probe_timebox
         return self._multiplexed_timeboxes[args]
 
@@ -876,11 +879,6 @@ class ShelvedMeasureTimeBox(TimeBox):
         return super().__radd__(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.
 
@@ -945,7 +943,7 @@ class Shelved_Measure_CustomWaveforms(Measure_CustomWaveforms, CompositeGate):
                 # 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:
+                if self.calibration_data["do_prx_12"] and abs(offset) > TIMING_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)
@@ -998,3 +996,123 @@ class Shelved_Measure_Constant(Shelved_Measure_CustomWaveforms, wave_i=Constant,
 
     A measure gate implemented as a constant waveform is surrounded by two `prx_12` gates.
     """
+
+
+class Fast_Measure_CustomWaveforms(Measure_CustomWaveforms):
+    """Measure implementation that blocks locus qubits for a shorter duration than the probes.
+
+    The locus qubits are blocked only for the physical probe pulse duration plus (calibratable) extra dead time that
+    can be used to take into account e.g. ring down delay of waiting the readout resonator to empty itself. The probe
+    channels are still blocked as in ``Measure_CustomWaveforms``, i.e. for the duration of
+    ``acquisition_delay + integration_length + integration_dead_time``.
+    """
+
+    root_parameters = Measure_CustomWaveforms.root_parameters | {
+        "locus_deadtime": Setting(
+            Parameter("locus_deadtime", "Locus dead time after the probe pulse", unit="s"),
+            0.0,
+        ),
+    }
+
+    def probe_timebox(  # type: ignore[override]
+        self, key: str = "", feedback_key: str = "", do_acquisition: bool = True, **kwargs
+    ) -> ProbeTimeBoxes:
+        """Otherwise the same as ``Measure_CustomWaveforms.probe_timebox``, but returns two TimeBoxes, the
+        actual MultiplexedProbeTimeBox and the rest of the probe-blocking wait time in its own TimeBox. This
+        allows the "tetris logic" in scheduling to block the locus qubits for a shorter duration.
+        """
+        args = (key, feedback_key, do_acquisition)
+        if args not in self._multiplexed_timeboxes:
+            if len(self.locus) == 1:
+                probe = self.builder.chip_topology.component_to_probe_line[self.locus[0]]
+                probe_channel = self.builder.get_probe_channel(self.locus[0])
+                try:
+                    drive_channel = self.builder.get_drive_channel(self.locus[0])
+                except KeyError:
+                    drive_channel = ""
+
+                combined_probe_timebox = super().probe_timebox(
+                    key, feedback_key, do_acquisition=do_acquisition, **kwargs
+                )
+                readout_trigger = combined_probe_timebox.atom[probe_channel][0]  # type: ignore[index]
+                actual_probe_duration = readout_trigger.probe_pulse.duration
+
+                # MultiplexedProbeTimeBox that has the minimum possible duration
+                if self.calibration_data["locus_deadtime"] > TIMING_TOLERANCE:
+                    deadtime = self.builder.channels[probe_channel].duration_to_int_samples(
+                        self.calibration_data["locus_deadtime"]
+                    )
+                else:
+                    deadtime = 0
+                # Must be: ReadoutTrigger.duration > ReadoutTrigger.probe_pulse.duration so if they would match, we
+                # need to add a minimum offset to make it hold, i.e. the smallest granularity allowed by the probe
+                # channel
+                probe_granularity = self.builder.channels[probe_channel].instruction_duration_granularity
+                offset = max(deadtime, probe_granularity)
+
+                truncated_readout_trigger = replace(readout_trigger, duration=actual_probe_duration + offset)
+                physical_probe_box = MultiplexedProbeTimeBox.from_readout_trigger(
+                    truncated_readout_trigger,
+                    probe_channel,
+                    locus_components=self.locus,
+                    label=f"Physical probe box of {self.__class__.__name__} on {self.locus}",
+                    block_channels=[drive_channel] if drive_channel else [],
+                    block_duration=truncated_readout_trigger.duration if drive_channel else 0,
+                )
+                physical_probe_box.neighborhood_components[0] = combined_probe_timebox.neighborhood_components[0].copy()
+                # extra Blocks (integration etc) for the probe channel
+                extra_block_duration = max(combined_probe_timebox.atom.duration - truncated_readout_trigger.duration, 0)  # type:ignore[union-attr]
+                virtual_extra_wait_box = TimeBox.atomic(
+                    Schedule({probe_channel: Segment([Block(extra_block_duration)])}),
+                    locus_components=[probe],
+                    label=f"Virtual probe extra wait box of {self.__class__.__name__} on {self.locus}",
+                )
+                virtual_extra_wait_box.neighborhood_components[0] = {probe}
+                final_boxes = ProbeTimeBoxes([physical_probe_box, virtual_extra_wait_box])
+            else:
+                # FIXME: all the return types in the measure impls need to be cleaned up
+                final_boxes = super().probe_timebox(key, feedback_key, do_acquisition=do_acquisition, **kwargs)  # type:ignore[assignment]
+            if feedback_key:
+                probelines = {self.builder.chip_topology.component_to_probe_line[q] for q in self.locus}
+                for probe in probelines:
+                    final_boxes[1].neighborhood_components[0].update(
+                        set(self.builder.get_virtual_feedback_channels(probe))
+                    )
+            self._multiplexed_timeboxes[args] = final_boxes  # type:ignore[assignment]
+            return final_boxes  # type:ignore[return-value]
+        return self._multiplexed_timeboxes[args]  # type:ignore[return-value]
+
+    def _call(self, key: str = "", feedback_key: str = "") -> list[TimeBox]:  # type:ignore[override]
+        """The same as ``Measure_CustomWaveforms._call``, i.e. wrap the "naked" multiplexable probe_timeboxes
+        into a composite TimeBox.
+        """
+        probe_box, wait_box = self.probe_timebox(key, feedback_key, do_acquisition=True)
+        final_box = TimeBox.composite([probe_box], label=f"Readout on {self.locus}")
+        final_box.neighborhood_components[0] = final_box.children[0].neighborhood_components[0]
+        return [final_box, wait_box]
+
+    def _get_probe_timebox_for_time_trace(self, key: str = "", feedback_key: str = "") -> TimeBox:
+        """Get the probe TimeBox for TimeTrace. This is just a single MultiplexedProbeTimeBox which has the full
+        probe duration (including integration). The faster logic wrt. qubit blocking is not important in the context of
+        TimeTraces.
+        """
+        # FIXME: not needed once we align the return types of all these measure gates
+        # Then we can make this method also shorter for the locus qubits
+        probe_boxes = self.probe_timebox(key, feedback_key, do_acquisition=True)
+        total_box = TimeBox.composite(self.probe_timebox(key, feedback_key, do_acquisition=True))
+        probe_schedule = self.builder.resolve_timebox(total_box, 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_boxes[0].locus_components,
+        )
+        atomic_probe_box.neighborhood_components[0] = probe_boxes[0].neighborhood_components[0]
+        return atomic_probe_box  # type:ignore[return-value]
+
+
+class Fast_Measure_Constant(Fast_Measure_CustomWaveforms, wave_i=Constant, wave_q=Constant):  # type:ignore[call-arg]
+    """Implementation of a faster measure with constant i and q waveforms.
+
+    Does not block the drive and flux channels of the locus qubits during the integration, but just during the probe
+    pulse and extra calibrated dead time after it.
+    """

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/playlist/instructions.py

@@ -15,9 +15,11 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import dataclasses
 from dataclasses import dataclass, field
 import random
+import re
 
 from iqm.pulse.playlist.waveforms import Waveform
 
@@ -271,3 +273,122 @@ class ReadoutTrigger(Instruction):
             ),
             acquisitions=self.acquisitions + other.acquisitions,
         )
+
+
+@dataclass
+class ReadoutMetrics:
+    """Aggregates the necessary readout metrics needed for return data processing."""
+
+    num_segments: int
+    """Number of segments in the Playlist this ReadoutMetrics object represents."""
+    integration_occurrences: dict[str, list[int]] = field(default_factory=dict)
+    """Map each integration readout label (of the format ``"<component>__<readout key>"``) to its number of occurrences
+    in each Playlist segment."""
+    timetrace_occurrences: dict[str, list[int]] = field(default_factory=dict)
+    """Map each time trace label (of the format ``"<component>__<readout key>"``) to its number of occurrences in each
+    Playlist segment."""
+    timetrace_lengths: dict[str, int] = field(default_factory=dict)
+    """Map each time trace label (of the format ``"<component>__<readout key>"``) to its number of time trace samples.
+    """
+    implementations: dict[str, set[str]] = field(default_factory=dict)
+    """Map each integration or time trace readout label to its implementations (of the format 
+    ``"<measure gate name>.<implementation name>"``)."""
+
+    def extend(self, trigger: ReadoutTrigger, seg_idx: int) -> None:
+        """Extend the metrics with a ReadoutTrigger in a given Playlist Segment.
+
+        Args:
+            trigger: The readout trigger.
+            seg_idx: The index of the Playlist segment ``trigger`` belongs to.
+
+        """
+        for acq in trigger.acquisitions:
+            if isinstance(acq, TimeTrace):
+                occurrences = self.timetrace_occurrences
+                if acq.label in self.timetrace_lengths:
+                    if self.timetrace_lengths[acq.label] != acq.duration_samples:
+                        raise ValueError(f"Time trace length mismatch in label {acq.label}")
+                else:
+                    self.timetrace_lengths[acq.label] = acq.duration_samples
+            else:
+                occurrences = self.integration_occurrences
+            if acq.label not in occurrences:
+                occurrences[acq.label] = [0] * self.num_segments
+            occurrences[acq.label][seg_idx] += 1
+            if acq.implementation is not None:
+                if acq.label not in self.implementations:
+                    self.implementations[acq.label] = set()
+                self.implementations[acq.label].add(acq.implementation)
+
+    def filter_out(
+        self,
+        labels: list[str] | None = None,
+        components: list[str] | None = None,
+        keys: list[str] | None = None,
+    ) -> None:
+        """Filter out labels from the contents in self.
+
+        Args:
+            labels: The labels to filter out.
+            components: The components to filter out (all labels for these components will be removed).
+            keys: The keys to filter out (all components with these keys will be removed).
+
+        """
+        labels = labels if labels else []
+        components = components if components else []
+        keys = keys if keys else []
+        for field_name in ["integration_occurrences", "timetrace_occurrences", "timetrace_lengths", "implementations"]:
+            field = getattr(self, field_name)
+            field_copy = field.copy()
+            for label, contents in field.items():
+                component, key = re.split("__[_]*", label)
+                if component in components or key in keys or label in labels:
+                    del field_copy[label]
+            setattr(self, field_name, field_copy)
+
+    def get_labels(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all the labels in self
+
+        Args:
+            integration: Whether to get integration labels.
+            timetrace: Whether to get time-trace labels.
+
+        Returns:
+            The applicable labels in self.
+
+        """
+        return self._get(lambda label: label, integration=integration, timetrace=timetrace)
+
+    def get_components(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all components in the labels in self
+
+        Args:
+            integration: Whether to get components from the integration labels.
+            timetrace:  Whether to get components from the time-trace labels.
+
+        Returns:
+            The applicable components in self.
+
+        """
+        return self._get(lambda label: re.split("__[_]*", label)[0], integration=integration, timetrace=timetrace)
+
+    def get_keys(self, integration: bool = True, timetrace: bool = True) -> set[str]:
+        """Get all readout keys in the labels in self
+
+        Args:
+            integration: Whether to get readout keys from the integration labels.
+            timetrace:  Whether to get readout keys from the time-trace labels.
+
+        Returns:
+            The applicable readout keys in self.
+
+        """
+        return self._get(lambda label: re.split("__[_]*", label)[1], integration=integration, timetrace=timetrace)
+
+    def _get(self, func: Callable, integration: bool = True, timetrace: bool = True) -> set[str]:
+        contents = []
+        if integration:
+            contents += [func(label) for label in self.integration_occurrences]
+        if timetrace:
+            contents += [func(label) for label in self.timetrace_occurrences]
+        return set(contents)

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm/pulse/timebox.py

@@ -122,8 +122,9 @@ class TimeBox:
      this ``TimeBox`` for any reason.
     """
 
-    @staticmethod
+    @classmethod
     def composite(
+        cls,
         boxes: Iterable[TimeBox | Iterable[TimeBox]],
         *,
         label: str = "",
@@ -155,7 +156,7 @@ class TimeBox:
             locus_components = set.union(*(box.locus_components for box in children))
         else:
             locus_components = set()
-        return TimeBox(
+        return cls(
             label=label,
             locus_components=locus_components,
             atom=None,
@@ -363,6 +364,8 @@ class MultiplexedProbeTimeBox(TimeBox):
                 scheduling_algorithm=self.scheduling_algorithm,
                 neighborhood_components=neighborhood_components,
             )
+        if isinstance(other, ProbeTimeBoxes):
+            return self + other[0]
         return super().__add__(other)
 
     @staticmethod
@@ -401,3 +404,61 @@ class MultiplexedProbeTimeBox(TimeBox):
             scheduling_algorithm=SchedulingAlgorithm.HARD_BOUNDARY,
         )
         return box
+
+
+class ProbeTimeBoxes(list):
+    """Allows multiplexing lists of probe TimeBoxes with each other and ``MultiplexedProbeTimeBox``es.
+
+    The first element is a ``MultiplexedProbeTimeBox`` and the second an atomic ``TimeBox`` containing ``Block``
+    instructions on probe channels (corresponding to e.g. the integration time).
+
+    If ``A`` is a ``ProbeTimeBoxes`` and ``B`` is a ``ProbeTimeBoxes``, then ``A+B`` is also a ProbeTimeBoxes instance
+    with the timings adjusted correctly and the ``MultiplexedProbeTimeBox``es in each multiplexed together.
+    If ``A`` is a ``ProbeTimeBoxes`` and ``B`` is a ``MultiplexedProbeTimeBox`` where the probe instructions are
+    multiplexed together and the duration is ``max(A[0].duration, B.duration)`` (the addition is symmetric).
+    Otherwise (if ``B`` is a list of ``Timebox``es or a non-probe ``TimeBox``), ``A+B`` works like
+    ``TimeBox.__add__``.
+    """
+
+    # FIXME: does not yet work with ShelvedProbeTimeBox
+    # All the measure gates should probably eventually return lists of TimeBoxes (that's the only way to "tetris"
+    # schedule stuff) and we should extend that to cover all the use cases, including Shelved.
+
+    def __init__(self, timeboxes: list[TimeBox]):
+        super().__init__(timeboxes)
+        if len(self) != 2:
+            raise ValueError(
+                "ProbeTimeBoxes instances must have exactly two elements, the first being the "
+                "MultiplexedProbeTimebox of the physical probe channels and the second the "
+                " extra Blocks in the probe channels."
+            )
+        if not isinstance(self[0], TimeBox) or self[0].atom is None or not isinstance(self[0], MultiplexedProbeTimeBox):
+            raise ValueError("The first child must be an atomic MultiplexedProbeTimeBox.")
+        if not isinstance(self[1], TimeBox) or self[1].atom is None:
+            raise ValueError(
+                "The second child must be an atomic TimeBox containing the extra Waits in the probe channels."
+            )
+
+    def __add__(self, other: TimeBox | list[TimeBox]) -> TimeBox | list[TimeBox]:  # type: ignore[override]
+        """Multiplex ``self`` with other ``ProbeTimeBoxes`` instances or with ``MultiplexedProbeTimeBox`` instances."""
+        if isinstance(other, ProbeTimeBoxes):
+            duration_self = sum(child.atom.duration for child in self)
+            duration_probe_self = self[0].atom.duration
+            duration_other = sum(child.atom.duration for child in other)
+            duration_probe_other = other[0].atom.duration
+            extra_wait_duration = max(duration_self, duration_other) - max(duration_probe_self, duration_probe_other)
+            extra_wait_channels = [*self[1].atom.channels(), *other[1].atom.channels()]
+            probe_box = self[0] + other[0]
+            extra_wait_box = TimeBox.atomic(
+                Schedule({ch: Segment([Block(extra_wait_duration)]) for ch in extra_wait_channels}),
+                locus_components=set(self[1].locus_components).union(other[1].locus_components),
+                label="Virtual probe channel Block",
+            )
+            if 0 in self[1].neighborhood_components and 0 in other[1].neighborhood_components:
+                extra_wait_box.neighborhood_components[0] = (
+                    self[1].neighborhood_components[0].union(other[1].neighborhood_components[0])
+                )
+            return ProbeTimeBoxes([probe_box, extra_wait_box])
+        if isinstance(other, MultiplexedProbeTimeBox):
+            return self[0] + other
+        return list(self) + other

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1/src/iqm_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.6.1
+Version: 12.7.1
 Summary: A Python-based project for providing interface and implementations for control pulses.
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License:                                  Apache License
@@ -204,7 +204,7 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-Project-URL: Documentation, https://iqm-finland.github.io/docs/iqm-pulse/
+Project-URL: Documentation, https://docs.meetiqm.com/iqm-pulse/
 Project-URL: Homepage, https://pypi.org/project/iqm-pulse/
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -213,7 +213,6 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: iqm-exa-common<28,>=27
 Requires-Dist: iqm-data-definitions<3.0,>=2.18
 Requires-Dist: python-rapidjson==1.20
 Requires-Dist: jinja2==3.0.3
@@ -226,7 +225,7 @@ IQM Pulse library
 
 A Python-based project for providing interface and implementations for control pulses.
 
-See `API documentation <https://iqm-finland.github.io/docs/iqm-pulse/>`_.
+See `API documentation <https://docs.meetiqm.com/iqm-pulse/>`_.
 
 Copyright
 ---------

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm_pulse.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ docs/_static/images/readout_timing.svg
 docs/_templates/autosummary-class-template.rst
 docs/_templates/autosummary-module-template.rst
 requirements/base.in
+requirements/base.in.internal
 requirements/base.txt
 src/iqm/pulse/__init__.py
 src/iqm/pulse/base_utils.py

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/src/iqm_pulse.egg-info/requires.txt

@@ -1,4 +1,3 @@
-iqm-exa-common<28,>=27
 iqm-data-definitions<3.0,>=2.18
 python-rapidjson==1.20
 jinja2==3.0.3

iqm_pulse-12.7.1/version.txt

@@ -0,0 +1 @@
+12.7.1

iqm_pulse-12.6.1/MANIFEST.in

@@ -1,10 +0,0 @@
-include CHANGELOG.rst
-prune changelog/
-include version.txt
-prune tests/*
-exclude docbuild
-exclude format
-exclude lint
-exclude sub-pyproject.toml
-exclude test
-exclude .gitlab-ci.yml

iqm_pulse-12.6.1/docs/changelog.rst

@@ -1,2 +0,0 @@
-.. _changes:
-.. include:: ../CHANGELOG.rst

iqm_pulse-12.6.1/version.txt

@@ -1 +0,0 @@
-12.6.1

{iqm_pulse-12.6.1 → iqm_pulse-12.7.1}/docs/index.rst

@@ -38,8 +38,8 @@ Contents
 .. toctree::
    :maxdepth: 1
 
-   Changelog <changelog>
    references
+   Changelog <changelog>
    License <license>