iqm-pulse 9.20.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

iqm/pulse/gates/measure.py

@@ -61,11 +61,11 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
     ``class MyGate(Measure_CustomWaveforms, i_wave=Something, q_wave=SomethingElse)``.
 
     The ``measure`` operation is factorizable, and its :attr:`arity` is 0, which together mean that it can operate
-    on loci of any dimensionality, but is calibrated only on single component loci. When the gate is constructed in the
-    ``len(locus) > 1``, case (e.g. ``builder.get_implementation('measure', ('QB1', 'QB2', 'QB3'))()``) the resulting
-    :class:`.TimeBox` is constructed from the calibrated single-component gates.
+    on loci of any length, but is calibrated only on single component loci. When the gate is constructed in the
+    ``len(locus) > 1`` case (e.g. ``builder.get_implementation('measure', ('QB1', 'QB2', 'QB3'))()``), the resulting
+    :class:`.TimeBox` is constructed from the calibrated single-component implementations.
 
-    For each measured component, the readout ``IQPulse`` will be modulated with the
+    For each measured component, the readout :class:`.IQPulse` will be modulated with the
     intermediate frequency (IF), computed as the difference between the readout
     frequency of that component and the probe line center frequency, and offset in phase
     by the readout phase of the component.
@@ -80,6 +80,7 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
         "frequency": Parameter("", "Readout pulse frequency", "Hz"),
         "phase": Parameter("", "Readout pulse phase", "rad"),
         "amplitude_i": Parameter("", "Readout channel I amplitude", ""),
+        # TODO do we really need these defaults? are they used anywhere?
         "amplitude_q": Setting(Parameter("", "Readout channel Q amplitude", ""), 0.0),
         "integration_length": Parameter("", "Integration length", "s"),
         "integration_weights_I": Setting(
@@ -105,36 +106,38 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
         self._time_traces: dict[tuple[str, float | None, float | None, str], TimeBox] = {}
         """Cache for :meth:`time_trace`."""
 
-        if len(locus) == 1:  # factorizable gates only need calibration on 1-loci
-            self._probe_line: ProbeChannelProperties = self.builder.channels[  # type: ignore[assignment]
-                self.builder.get_probe_channel(self.locus[0])
+        if len(locus) == 1:
+            # prepare the single-component measurement
+            probe_line: ProbeChannelProperties = builder.channels[  # type: ignore[assignment]
+                builder.get_probe_channel(locus[0])
             ]
-            c_freq = self._probe_line.center_frequency
-            if_freq = (calibration_data["frequency"] - c_freq) / self._probe_line.sample_rate
+            # readout duration is determined by the acquisition, probe pulses are truncated to fit this window
             self._duration = (
-                self._probe_line.duration_to_int_samples(
-                    self._probe_line.round_duration_to_granularity(
+                probe_line.duration_to_int_samples(
+                    probe_line.round_duration_to_granularity(
                         calibration_data["acquisition_delay"] + calibration_data["integration_length"]
                     )
                 )
-                + self._probe_line.integration_stop_dead_time
+                + probe_line.integration_stop_dead_time
             )
-
+            self._probe_offset = probe_line.integration_start_dead_time
+            # "duration" is only used by the probe pulse
             waveform_params = self.convert_calibration_data(
                 calibration_data,
-                {k: v for k, v in self.parameters.items() if k not in self.root_parameters or k == "duration"},
-                self._probe_line,
+                {k: v for k, v in self.parameters.items() if k not in self.root_parameters},
+                probe_line,
             )
+            # unconverted cal data that corresponds to a root param (not duration)
             root_params = {k: v for k, v in calibration_data.items() if k in self.root_parameters and k != "duration"}
+            # do some conversions TODO are these consistent?
+            root_params["integration_length"] = probe_line.duration_to_int_samples(root_params["integration_length"])
+            root_params["acquisition_delay"] = round(probe_line.duration_to_samples(root_params["acquisition_delay"]))
 
-            probe_instruction, acquisition_method = self._build_instructions(waveform_params, root_params, if_freq)
-            self._probe_instruction = probe_instruction
-            self._acquisition_method = acquisition_method
-            self._prio_calibration: OILCalibrationData | None = None
-        else:
-            # we need to store the possible cal_data == priority calibration in order to propagate it to the factored
-            # single-component measure calls in :meth:`probe_timebox`
-            self._prio_calibration = calibration_data or None
+            if_freq = (calibration_data["frequency"] - probe_line.center_frequency) / probe_line.sample_rate
+
+            self._probe_instruction, self._acquisition_method = self._build_instructions(
+                waveform_params, root_params, if_freq
+            )
 
     def _build_instructions(
         self, waveform_params: OILCalibrationData, root_params: OILCalibrationData, if_freq: float
@@ -160,7 +163,7 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
             modulation_frequency=if_freq,
         )
 
-        integration_length = self._probe_line.duration_to_int_samples(root_params["integration_length"])
+        integration_length = root_params["integration_length"]
         weights_i = root_params.get("integration_weights_I")
         weights_q = root_params.get("integration_weights_Q")
         if weights_i is not None and weights_i.size and weights_q is not None and weights_q.size:
@@ -195,16 +198,15 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
             )
 
         acquisition_type = root_params.get("acquisition_type", self.root_parameters["acquisition_type"].value)  # type: ignore[union-attr]
-        acquisition_delay = round(self._probe_line.duration_to_samples(root_params["acquisition_delay"]))
         acquisition_label = "TO_BE_REPLACED"
         if acquisition_type == "complex":
             acquisition_method = ComplexIntegration(
-                label=acquisition_label, delay_samples=acquisition_delay, weights=weights
+                label=acquisition_label, delay_samples=root_params["acquisition_delay"], weights=weights
             )
         elif acquisition_type == "threshold":
             acquisition_method = ThresholdStateDiscrimination(
                 label=acquisition_label,
-                delay_samples=acquisition_delay,
+                delay_samples=root_params["acquisition_delay"],
                 weights=weights,
                 threshold=root_params["integration_threshold"],
             )
@@ -243,12 +245,11 @@ class Measure_CustomWaveforms(CustomIQWaveforms):
                 replacements = {"label": f"{self.locus[0]}__{label_key}"}
                 if feedback_key and isinstance(self._acquisition_method, ThresholdStateDiscrimination):
                     # TODO: use the actual ``feedback_key`` when AWGs support multiple feedback labels
-                    feedback_bit = f"{self.locus[0]}__{FEEDBACK_KEY}"
-                    replacements["feedback_signal_label"] = feedback_bit
+                    replacements["feedback_signal_label"] = f"{self.locus[0]}__{FEEDBACK_KEY}"
                 acquisitions = (replace(self._acquisition_method, **replacements),) if do_acquisition else ()  # type: ignore[arg-type]
                 multiplexed_iq = MultiplexedIQPulse(
-                    duration=self._probe_instruction.duration + self._probe_line.integration_start_dead_time,
-                    entries=((self._probe_instruction, self._probe_line.integration_start_dead_time),),
+                    duration=self._probe_instruction.duration + self._probe_offset,
+                    entries=((self._probe_instruction, self._probe_offset),),
                 )
                 readout_trigger = ReadoutTrigger(
                     duration=self._duration, probe_pulse=multiplexed_iq, acquisitions=acquisitions
@@ -286,12 +287,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.builder.get_implementation(  # type: ignore[attr-defined]
-                        self.parent.name, (c,), impl_name=self.name, priority_calibration=self._prio_calibration
-                    ).probe_timebox(key, feedback_key, do_acquisition, _skip_override=True)
+                    self.sub_implementations[c].probe_timebox(key, feedback_key, do_acquisition, _skip_override=True)  # type: ignore[attr-defined]
                     for c in self.locus
                 ]
                 probe_timebox = functools.reduce(lambda x, y: x + y, probe_timeboxes)
@@ -446,10 +447,14 @@ class ProbePulse_CustomWaveforms(CustomIQWaveforms):
     With given :class:`.Waveform` waveform definitions ``Something`` and ``SomethingElse``,
     you may define a measurement implementation that uses them as follows:
     ``class MyGate(ProbePulse_CustomWaveforms, i_wave=Something, q_wave=SomethingElse)``.
+    The measurement :class:`.IQPulse` instruction will not be automatically modulated
+    by any frequency, so any modulations should be included in the I and Q waveforms themselves.
+
+    Due to device limitations this implementation also has to integrate the readout signal
+    (using arbitrary weights), even though it does not make much sense.
 
     Contrary to the ``Measure_CustomWaveforms`` class, this implementation acts on proble lines directly (i.e. its
-    ``locus`` is a single probe line). The measurement ``IQPulse`` instruction will not be automatically modulated
-    by any frequency, so any modulations should be included in the I and Q waveforms themselves.
+    ``locus`` is a single probe line).
     """
 
     root_parameters = {
@@ -465,8 +470,8 @@ class ProbePulse_CustomWaveforms(CustomIQWaveforms):
         self, parent: QuantumOp, name: str, locus: Locus, calibration_data: OILCalibrationData, builder: ScheduleBuilder
     ):
         super().__init__(parent, name, locus, calibration_data, builder)
-        self._probe_line: ProbeChannelProperties = self.builder.channels[  # type: ignore[assignment]
-            self.builder.component_channels[self.locus[0]]["readout"]
+        self._probe_line: ProbeChannelProperties = builder.channels[  # type: ignore[assignment]
+            builder.component_channels[locus[0]]["readout"]
         ]
         self._duration = (
             self._probe_line.duration_to_int_samples(
@@ -479,7 +484,7 @@ class ProbePulse_CustomWaveforms(CustomIQWaveforms):
 
         waveform_params = self.convert_calibration_data(
             calibration_data,
-            {k: v for k, v in self.parameters.items() if k not in self.root_parameters or k == "duration"},
+            {k: v for k, v in self.parameters.items() if k not in self.root_parameters},
             self._probe_line,
         )
         root_params = {k: v for k, v in calibration_data.items() if k in self.root_parameters and k != "duration"}
@@ -602,8 +607,8 @@ class ProbePulse_CustomWaveforms_noIntegration(CustomIQWaveforms):
         """Cache for :meth:`probe_timebox`."""
 
         if len(locus) == 1:  # factorizable gates only need calibration on 1-loci
-            self._probe_line: ProbeChannelProperties = self.builder.channels[  # type: ignore[assignment]
-                self.builder.get_probe_channel(self.locus[0])
+            self._probe_line: ProbeChannelProperties = builder.channels[  # type: ignore[assignment]
+                builder.get_probe_channel(locus[0])
             ]
             c_freq = self._probe_line.center_frequency
             if_freq = (calibration_data["frequency"] - c_freq) / self._probe_line.sample_rate

iqm/pulse/gates/prx.py

@@ -211,11 +211,6 @@ class PRX_SinglePulse_GateImplementation(SinglePulseGate, PrxGateImplementation)
         timebox.neighborhood_components[0] = set(self.locus)
         return timebox
 
-    @property
-    def iq_pulse(self) -> IQPulse:
-        """Alias for ``self.pulse`` for backward compatibility"""
-        return self.pulse  # type: ignore[return-value]
-
 
 class PRX_CustomWaveforms(PRX_SinglePulse_GateImplementation, CustomIQWaveforms):
     """Base class for PRX gates implemented using a single IQ pulse and hot-swappable waveforms."""

iqm/pulse/gates/reset.py

@@ -18,7 +18,7 @@ The reset operation is a non-unitary quantum channel that sets the state of a qu
 
 from __future__ import annotations
 
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 
 from exa.common.data.parameter import Parameter
 from exa.common.qcm_data.chip_topology import ChipTopology
@@ -53,7 +53,7 @@ class Reset_Conditional(CompositeGate):
     blocked.
     """
 
-    registered_gates = ["measure"]
+    registered_gates = ("measure", "cc_prx")
 
     def _call(self) -> TimeBox:  # type: ignore[override]
         # find locus components that are resettable via conditional reset
@@ -120,15 +120,8 @@ class Reset_Wait(GateImplementation):
         if len(self.locus) == 1:
             waits_box = self.builder.wait(self.locus, self.calibration_data["duration"], rounding=True)
         else:
-            prio_calibration = self.calibration_data if self.calibration_data else None
-            waits_box = TimeBox.composite(
-                [
-                    self.builder.get_implementation(  # type: ignore[attr-defined]
-                        self.parent.name, (q,), impl_name=self.name, priority_calibration=prio_calibration
-                    ).wait_box()
-                    for q in self.locus
-                ]
-            )
+            # factorizability: use the sub-implementations
+            waits_box = TimeBox.composite([self.sub_implementations[c].wait_box() for c in self.locus])  # type: ignore[attr-defined]
         return waits_box
 
     def _call(self) -> TimeBox:
@@ -147,14 +140,13 @@ class Reset_Wait(GateImplementation):
         return TimeBox.composite([waits_box])
 
     def duration_in_seconds(self) -> float:
-        return max(
-            self.builder.get_implementation(self.parent.name, (q,), impl_name=self.name).calibration_data["duration"]
-            for q in self.locus
-        )
+        if len(self.locus) == 1:
+            return self.calibration_data["duration"]
+        return max(self.sub_implementations[c].calibration_data["duration"] for c in self.locus)
 
     @classmethod
     def get_custom_locus_mapping(
-        cls, chip_topology: ChipTopology, component_to_channels: dict[str, Iterable[str]]
+        cls, chip_topology: ChipTopology, component_to_channels: Mapping[str, Iterable[str]]
     ) -> dict[tuple[str, ...] | frozenset[str], tuple[str, ...]] | None:
         """Supported loci: all components that have channels."""
         return {(c,): (c,) for c in chip_topology.all_components}

iqm/pulse/gates/rz.py

@@ -251,7 +251,7 @@ class RZ_ACStarkShift_smoothConstant(  # type: ignore[call-arg]  # type: ignore[
 class RZ_PRX_Composite(CompositeGate):
     """RZ gate implemented as a sequence of PRX gates."""
 
-    registered_gates = ["prx"]
+    registered_gates = ("prx",)
 
     def __init__(self, parent, name, locus, calibration_data, builder):
         super().__init__(parent, name, locus, calibration_data, builder)

iqm/pulse/gates/sx.py

@@ -38,7 +38,7 @@ if TYPE_CHECKING:  # pragma: no cover
 class SXGate(CompositeGate):
     """SX gate implementation based on PRX gate, by limiting the angle to pi / 2."""
 
-    registered_gates = ["prx"]
+    registered_gates = ("prx",)
 
     def _call(self) -> TimeBox:  # type: ignore[override]
         """Call PRX gate with angle equals to pi / 2."""

iqm/pulse/gates/u.py

@@ -91,7 +91,7 @@ class UGate(CompositeGate):
     Assumes the chosen PRX implementation uses resonant driving, and that the virtual RZ technique can be used.
     """
 
-    registered_gates = ["prx"]
+    registered_gates = ("prx",)
 
     def _call(self, theta: float, phi: float = 0.0, lam: float = 0.0) -> TimeBox:  # type: ignore[override]
         r"""Convert pulses into timebox, via Euler decomposition.

iqm/pulse/playlist/instructions.py

@@ -136,17 +136,17 @@ class IQPulse(Instruction):
     scale_q: float = 0.0
     """Scaling factor for the Q quadrature."""
     phase: float = 0.0
-    """Phase of the pulse relative to the channel frequency, in radians."""
+    """Phase of the pulse relative to the channel upconversion oscillator ("carrier wave"), in radians."""
     modulation_frequency: float = 0.0
     """Modulation frequency of the waveforms, in units of the sampling rate.
-    This modulation is additional to the channel frequency.
+    This modulation is additional to the channel upconversion frequency.
     The default value of 0.0 does not modulate.
     Note that the phase of this modulation resets for every instruction, that is, successive instances of the same
     modulated pulse are not phase coherent.
     """
     phase_increment: float = 0.0
-    """Relative phase increment to the phase in the carrier frequency of this pulse and all pulses that
-    are played after it. Unit: rad.
+    """Phase increment for the channel upconversion oscillator ("carrier wave"), affecting this pulse and
+    all pulses that are played after it on the channel, in radians.
     """
 
     def validate(self):
@@ -165,9 +165,9 @@ class ConditionalInstruction(Instruction):
     """Choice between multiple Instructions, depending on a condition."""
 
     condition: str
-    """can be evaluated to an integer >= 0"""
+    """Can be evaluated to an integer >= 0 representing an outcome."""
     outcomes: tuple[Instruction, ...]
-    """maps possible outcomes of the condition to the corresponding instructions"""
+    """Maps possible outcomes of the condition to the corresponding instructions."""
 
     def validate(self):
         super().validate()
@@ -186,7 +186,7 @@ class ConditionalInstruction(Instruction):
 
 @dataclass(frozen=True)
 class MultiplexedIQPulse(Instruction):
-    """Instruction to simultaneously play multiple IQ pulses.
+    """Play the sum of multiple IQ pulses.
 
     Each component pulse can have an arbitrary delay from the beginning of this instruction.
     Outside the interval of the MultiplexedIQPulse, the component pulses are truncated.

iqm/pulse/quantum_ops.py

@@ -27,7 +27,7 @@ import numpy as np
 from iqm.pulse.base_utils import merge_dicts
 
 if TYPE_CHECKING:  # pragma: no cover
-    from iqm.pulse.gate_implementation import GateImplementation, OILCalibrationData, OpCalibrationDataTree
+    from iqm.pulse.gate_implementation import GateImplementation, Locus, OILCalibrationData, OpCalibrationDataTree
 
 
 @dataclass(frozen=True)
@@ -73,7 +73,7 @@ class QuantumOp:
 
     name: str
     """Unique name of the operation."""
-    arity: int
+    arity: int = 1
     """Number of locus components the operation acts on.
     Each locus component corresponds to a quantum subsystem in the definition of the operation.
     The computational subspace always consists of the lowest two levels of the subsystem.
@@ -92,7 +92,7 @@ class QuantumOp:
     """True iff the operation is always factorizable to independent single-subsystem operations, which
     is also how it is implemented, for example parallel single-qubit measurements.
     In this case the operation calibration data is for individual subsystems as well."""
-    defaults_for_locus: dict[tuple[str, ...], str] = field(default_factory=dict)
+    defaults_for_locus: dict[Locus, str] = field(default_factory=dict)
     """Optionally define the implementation default individually per each locus. Maps the locus to the default
     gate implementation name. If a locus is not found in this dict (by default, the dict is empty), falls back to the
     global order defined in ``implementations``. The implementations must be first registered in ``implementations``."""
@@ -140,7 +140,6 @@ class QuantumOp:
             ValueError: ``default`` is unknown or is a special implementation.
 
         """
-        # breakpoint()
         if (impl := self.implementations.get(default)) is None:
             raise ValueError(f"Operation '{self.name}' has no implementation named '{default}'.")
 
@@ -233,7 +232,7 @@ def validate_op_calibration(calibration: OpCalibrationDataTree, ops: QuantumOpTa
 
 
 def validate_locus_calibration(
-    cal_data: OILCalibrationData, impl: type[GateImplementation], op: QuantumOp, impl_name: str, locus: tuple[str, ...]
+    cal_data: OILCalibrationData, impl: type[GateImplementation], op: QuantumOp, impl_name: str, locus: Locus
 ) -> None:
     """Validates calibration for a particular gate implementation at particular locus.
 
@@ -250,17 +249,14 @@ def validate_locus_calibration(
     """
     if not locus:
         return  # default cal data for all loci
-    # Remove registered gates from calibration so that validation has a chance to succeed for composite gates.
-    # This validation is done anyway when constructing the registered gates themselves, so it is not necessary
-    # to do it twice.
-    cal_data_copy = cal_data.copy()
-    if hasattr(impl, "registered_gates"):
-        registered_gates = impl.registered_gates
-        for gate in registered_gates:
-            if gate in cal_data_copy:
-                del cal_data_copy[gate]
-    # since OILCalibrationData can have nested dicts, we do a recursive diff
-    _diff_dicts(cal_data_copy, impl.parameters, [], op.name, impl_name, locus)
+
+    # Some implementations have optional calibration parameters which we ignore here,
+    # e.g. customizable member gate cal data for CompositeGates.
+    # Since OILCalibrationData can have nested dicts, we do a recursive diff.
+    try:
+        _diff_dicts(cal_data, impl.parameters, set(impl.optional_calibration_keys()), [])
+    except ValueError as exc:
+        raise ValueError(f"{op.name}.{impl_name} at {locus}: {exc}") from exc
 
     n_components = len(locus)
     arity = op.arity
@@ -274,29 +270,31 @@ def validate_locus_calibration(
         raise ValueError(f"{op.name}.{impl_name} at {locus}: locus must have {arity} component(s)")
 
 
-def _diff_dicts(cal_data: dict[str, Any], impl_parameters: dict[str, Any], path, op_name, impl_name, locus) -> None:
-    """Compare the calibration"""
-    full = set(impl_parameters)
+def _diff_dicts(
+    cal_data: dict[str, Any], impl_parameters: dict[str, Any], ignored_keys: set[str], path: list[str]
+) -> None:
+    """Compare calibration data to the expected parameters."""
+    all_parameters = set(impl_parameters)
+    # some gate params have default values
     defaults = {k: v.value for k, v in impl_parameters.items() if hasattr(v, "value")}
+    # FIXME what is the defaults logic below? is it correct? needs a comment
     have = {k for k, v in cal_data.items() if v is not None or (k in defaults and defaults[k] is None)}
-    need = set(impl_parameters) - set(defaults)
+    need = all_parameters - set(defaults)
     if need == {"*"}:
-        return
-    if diff := have - full:
-        raise ValueError(f"Unknown calibration data for {op_name}.{impl_name} at {locus}: {'.'.join(path)} {diff}")
+        return  # wildcard parameters are optional at any level
+    if diff := have - all_parameters - ignored_keys:
+        raise ValueError(f"Unknown calibration data {'.'.join(path)}.{diff}")
     if diff := need - have:
-        raise ValueError(f"Missing calibration data for {op_name}.{impl_name} at {locus}: {'.'.join(path)} {diff}")
+        raise ValueError(f"Missing calibration data {'.'.join(path)}.{diff}")
     for key, data in cal_data.items():
+        if key in ignored_keys:
+            continue
         required_value = impl_parameters[key]
         new_path = path + [key]
         if isinstance(required_value, dict):
             if isinstance(data, dict):
-                _diff_dicts(data, required_value, new_path, op_name, impl_name, locus)
+                _diff_dicts(data, required_value, set(), new_path)
             else:
-                raise ValueError(
-                    f"Calibration data for {op_name}.{impl_name} at {locus}: '{'.'.join(new_path)}' should be a dict"
-                )
+                raise ValueError(f"Calibration data item '{'.'.join(new_path)}' should be a dict")
         elif isinstance(data, dict):
-            raise ValueError(
-                f"Calibration data for {op_name}.{impl_name} at {locus}: '{'.'.join(new_path)}' should be a scalar"
-            )
+            raise ValueError(f"Calibration data item '{'.'.join(new_path)}' should be a scalar")

iqm/pulse/utils.py

@@ -17,14 +17,11 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable
-import copy
 from typing import get_args, get_origin
 
 import numpy as np
 
 from exa.common.data.parameter import CollectionType, DataType
-from iqm.pulse.quantum_ops import QuantumOpTable
 
 
 def map_waveform_param_types(type_hint: type) -> tuple[DataType, CollectionType]:
@@ -110,92 +107,3 @@ def phase_transformation(psi_1: float = 0.0, psi_2: float = 0.0) -> tuple[float,
 
     """
     return psi_2, -(psi_1 + psi_2)
-
-
-def _validate_locus_defaults(op_name: str, definition: dict, implementations: dict) -> None:
-    """Validate that locus defaults reference valid implementations.
-
-    Args:
-        op_name: Name of the gate we want to validate
-        definition: Dictionary containing the parameters of the new operation
-        implementations: Available implementations for the operation
-
-    Raises:
-        ValueError: If locus default references invalid implementation
-
-    """
-    for locus, impl_name in definition["defaults_for_locus"].items():
-        if impl_name not in implementations:
-            raise ValueError(
-                f"defaults_for_locus[{locus}] implementation '{impl_name}' does not "
-                f"appear in the implementations field of {op_name}."
-            )
-
-
-def _validate_op_attributes(op_name: str, definition: dict, op_table: QuantumOpTable) -> None:
-    """Assert that the attributes of the operation (other than default implementation info) are not changed.
-
-    Args:
-        op_name: Name of the quantum operation to be added to table of quantum operations
-        definition: Dictionary containing the parameters of the new operation
-        op_table: Table of default or existing quantum operations
-
-    Raises:
-        ValueError: If attributes don't match defaults or are invalid
-
-    """
-    for attribute_name, value in definition.items():
-        if not hasattr(op_table[op_name], attribute_name):
-            raise ValueError(f"QuantumOp {op_name} has no attribute '{attribute_name}'.")
-
-        default_value = getattr(op_table[op_name], attribute_name)
-        if isinstance(value, Iterable):
-            default_value = tuple(default_value)
-            value = tuple(value)  # noqa: PLW2901
-        if attribute_name not in ("implementations", "defaults_for_locus") and default_value != value:
-            raise ValueError(
-                "The QuantumOp definition provided by the user has a different value in the"
-                f" attribute {attribute_name} compared to the QuantumOp definition in iqm-pulse "
-                f" ({value} != {default_value}). "
-                "Changing the attributes of default QuantumOps is not allowed, other than"
-                "implementations and defaults_for_locus."
-            )
-
-
-def _process_implementations(
-    op_name: str, new_implementations: dict, exposed_implementations: dict, _default_implementations: dict
-) -> dict:
-    """Processes implementation definitions into implementation classes.
-
-    Args:
-        op_name: Name of the quantum operation
-        new_implementations: Dictionary mapping implementation names to class names
-        exposed_implementations: Dictionary containing the exposed implementations
-        _default_implementations: Dictionary containing the default mappings between implementations
-        and implementation classes for different gates
-
-    Returns:
-        Dictionary mapping implementation names to implementation classes
-
-    Raises:
-        ValueError: If implementation class is not exposed
-        ValueError: If implementation is overriding a default implementation
-
-    """
-    implementations = {}
-    default_implementations = copy.deepcopy(_default_implementations).get(op_name, {})
-    for new_impl_name, new_impl_cls in new_implementations.items():
-        if (impl := exposed_implementations.get(new_impl_cls)) is None:
-            raise ValueError(f"Implementation {new_impl_cls} has not been exposed.")
-        # check if the implementation is overriding a default implementation
-        for def_impl_name, def_impl_cls in default_implementations.items():
-            if new_impl_name == def_impl_name:
-                def_impl_class_name = def_impl_cls if isinstance(def_impl_cls, str) else def_impl_cls.__name__
-                if new_impl_cls != def_impl_class_name:
-                    raise ValueError(
-                        f"'{def_impl_class_name}' is the default GateImplementation class for implementation '{def_impl_name}' and cannot be overridden. Consider adding a new implementation with a different name."  # noqa: E501
-                    )
-
-        implementations[new_impl_name] = impl
-
-    return implementations

{iqm_pulse-9.20.0.dist-info → iqm_pulse-10.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 9.20.0
+Version: 10.0.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-9.20.0.dist-info → iqm_pulse-10.0.0.dist-info}/RECORD

@@ -1,34 +1,34 @@
 iqm/pulse/__init__.py,sha256=FxgHlv3bF8bQCREwOJ1yu_nsrfJq0g0HdovvT1wUnCI,881
 iqm/pulse/base_utils.py,sha256=tLbmnWGmHsjcA8QFCiqvHfgSJJNWS4AVTcD2y4M2ipU,2641
-iqm/pulse/builder.py,sha256=G9AydyZHy3YX6h-BMvPxqqcMieTRq1PoWJ_Bau9uWH4,67024
-iqm/pulse/circuit_operations.py,sha256=i6v6dW-F_YATSFwZWbi8OTkcS_HCAqfJdfZ7ZfVzcmU,22743
-iqm/pulse/gate_implementation.py,sha256=iD9qdXbcJVXqa8xU0gJ1KSkhe02NsXpbmuAiRvvAdWo,33956
+iqm/pulse/builder.py,sha256=YB-oiCqOka32Xyyjydomzq_tIwaE_4LsHkyLI4zGWCk,72482
+iqm/pulse/circuit_operations.py,sha256=i-sUx-JZOKAMKWgYq1c5KIR2Ons9Uyq_meEmppAmwI8,22387
+iqm/pulse/gate_implementation.py,sha256=yyj2d1aDL0K_qouo0qLHnZ49_1qHsJEShKW14398t8Q,39546
 iqm/pulse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/pulse/quantum_ops.py,sha256=-ufAogPszeh1z23Qr3BeDH6L-vJAWauUZLJ5Xoqd4cY,14758
+iqm/pulse/quantum_ops.py,sha256=UTQ08Eo5vFpV_lOoQNtlwRTchES6BdGHQ5pzSdb1ToY,14584
 iqm/pulse/scheduler.py,sha256=62gH3AcxmsgmShcmtNaiCqFLRl1Wll6Q24zIkhw_-XM,22768
 iqm/pulse/timebox.py,sha256=Yi8I43KiSPs2s_l1r0rMVm4mw0EpSCrpq3BCUNk5vyE,16618
-iqm/pulse/utils.py,sha256=HyTkMD0er_rZnvDZWM1WscOFxaxGMyRAW_Aw36b0Hdc,7998
+iqm/pulse/utils.py,sha256=0J4KQNvKtZahme7sP7vLa1FtENepC-eb9_A5WaghvVU,3710
 iqm/pulse/validation.py,sha256=-tZWrW201t4nbTQWeZ8M9DixzoN8B0Q63IP57BfDAz0,10733
-iqm/pulse/gates/__init__.py,sha256=uvEfNMEd7-jp-PxbZ8F-9IpocFUQ_T_JEPZrZZpPBxQ,13348
+iqm/pulse/gates/__init__.py,sha256=Hd0mKWw55afvgOhDD_dgaPNCLZR6LSUoywwjBgB5zd4,8719
 iqm/pulse/gates/barrier.py,sha256=WhYV70lf4lh4Wa9UZuMk2lp9JbUQIu8lzewRC2P7pNE,2546
-iqm/pulse/gates/conditional.py,sha256=NULUlVv4UNYHHILFIxvjPtWE1bg_nQu8lIXmBkBDBcM,6304
-iqm/pulse/gates/cz.py,sha256=1v72BQu2KByYZ43sFnM9ookIj_0DyFGPdIR6RbtXzLQ,20294
-iqm/pulse/gates/default_gates.py,sha256=NY_fduPHVyelaRFhi9BGokescSPxpouB9LY5ISUZsyE,10421
+iqm/pulse/gates/conditional.py,sha256=NE-1GYlFcfaCmRuhqGEIhtoJmBArhyY5KhVnO4y4zng,6289
+iqm/pulse/gates/cz.py,sha256=CkTHqw6417cvZ7FDjx-e727tNpHG3PCdrpmaH7RtgOE,19855
+iqm/pulse/gates/default_gates.py,sha256=KWcwWowkBlLkpqxcPiX6dxLpAb7DZr3FLskaba5__I4,7303
 iqm/pulse/gates/delay.py,sha256=nST9dY2JFp_mpKhiSfsYa5yL4hFKcNJSAyCzXjhauQg,3767
 iqm/pulse/gates/enums.py,sha256=ATwb6vZYpfgQ1gQyFPW53JyIKrdAP3FPHm6jV-t9OAk,2532
-iqm/pulse/gates/flux_multiplexer.py,sha256=fUAg-biUcl6buWlANd2pOrBibOlLqO-lOSC7ZwZ7_xA,9745
-iqm/pulse/gates/measure.py,sha256=rKMTS-X4xWhyzU9F64B-8G6IQPRP2W30mCkwUiG_43Q,44392
+iqm/pulse/gates/flux_multiplexer.py,sha256=sk84ItEvkx7Z0pCHt8MCCczBe7_BHNvqS4_oeNghZw8,9757
+iqm/pulse/gates/measure.py,sha256=5yG5dQeDljZewrPdy6vwejz5m3KU-9SlXQco9oAyssw,44488
 iqm/pulse/gates/move.py,sha256=L8wDcc7He43sUrwQs24lNydxdM9bKN27zlEdnDucDfc,17490
-iqm/pulse/gates/prx.py,sha256=vf6tb7A6EzYm8GGJdcX7m9sKmToPODty-vQ8F1Mmhqw,25150
-iqm/pulse/gates/reset.py,sha256=6rpAfboNlINylDNphePGotbex-PtMKL_PnDXr2J4nK8,7706
-iqm/pulse/gates/rz.py,sha256=UYVyMfJZR9fl29vCiFPGz4RxJt__v0VK35Whkjlhc0Q,9683
-iqm/pulse/gates/sx.py,sha256=kNEBtkUMrbSMkvbLN78XuNjTR00NLQeZqBGilIAI98E,1735
-iqm/pulse/gates/u.py,sha256=lpj0dT7ktkStUSD4roPBn-8OLHrJYyQAHTuU0bm5kJg,5402
+iqm/pulse/gates/prx.py,sha256=Vl7t26mDRjj-6sC8jmpAgzTAtaTubVx6Ib_lpx_HmCk,24978
+iqm/pulse/gates/reset.py,sha256=idsknRq_z2JKIq4zXc4LvdE2czE5-KgGTdLPmYVyWIg,7480
+iqm/pulse/gates/rz.py,sha256=kr8Y5ap1MN81InCSmzGkxejvUcNszl1sxpG7yacvDM0,9684
+iqm/pulse/gates/sx.py,sha256=3s7lo5ib2HZh-kzZd95-JqL41LxCX5GA4QZ0h7u3WCQ,1736
+iqm/pulse/gates/u.py,sha256=EUX84XkawqLhwRaJ1MxSKB33VpC8XDsFu875uHNo0WI,5403
 iqm/pulse/playlist/__init__.py,sha256=XW-7Po_vCzhkk1Js06K8P-5srPpBuPHkqpc1yhL_Zx4,997
 iqm/pulse/playlist/channel.py,sha256=RAkGyjTU66MiF-ccf06FFZAXpUykWEltbfNXw4xJpYc,17164
 iqm/pulse/playlist/fast_drag.py,sha256=80Knv0Q9IaGiVdc0TrHlxNi1zJtTUZvWIVO38reYcA0,19600
 iqm/pulse/playlist/hd_drag.py,sha256=JYRy3aPu0LD9y0H3UncOiWI39eV9-TARvgLonNUsaO0,13562
-iqm/pulse/playlist/instructions.py,sha256=K4c8TwC9FBbD_kdPD2OpjG1OZsDJALlwJon4SD9etk8,9845
+iqm/pulse/playlist/instructions.py,sha256=PyIjJJN58rbfIFqgRaynsnsHXywy6xBpkAtQuifgoJY,9930
 iqm/pulse/playlist/playlist.py,sha256=7MIX4iRfh2Nit8AnpNyqv5A5ZmK7JR-v201DXVL6kUk,685
 iqm/pulse/playlist/schedule.py,sha256=VYrVyPlB04Rm8iOYBXu2uOpsLBqczJRx3L2VU53CxVU,17989
 iqm/pulse/playlist/waveforms.py,sha256=Xa7P3V0rRIn7sQIoLKqXaWwtAbyQWjdVGW6bKOGNcOQ,17898
@@ -39,8 +39,8 @@ iqm/pulse/playlist/visualisation/templates/static/logo.png,sha256=rbfQZ6_UEaztpY
 iqm/pulse/playlist/visualisation/templates/static/moment.min.js,sha256=4iQZ6BVL4qNKlQ27TExEhBN1HFPvAvAMbFavKKosSWQ,53324
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.css,sha256=svzNasPg1yR5gvEaRei2jg-n4Pc3sVyMUWeS6xRAh6U,19837
 iqm/pulse/playlist/visualisation/templates/static/vis-timeline-graph2d.min.js,sha256=OqCqCyA6JnxPz3PGXq_P_9VuSqWptgNt5Ev3T-xjefQ,570288
-iqm_pulse-9.20.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_pulse-9.20.0.dist-info/METADATA,sha256=P35RKE4Ooe9mXe6ifYgmX2B3wCKo5p21MVAdDngKEU8,14551
-iqm_pulse-9.20.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_pulse-9.20.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_pulse-9.20.0.dist-info/RECORD,,
+iqm_pulse-10.0.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_pulse-10.0.0.dist-info/METADATA,sha256=5-Re6d58u6Ek98qU8ea3CyYKoH5kh2eGw7lkTvGZQXI,14551
+iqm_pulse-10.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_pulse-10.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_pulse-10.0.0.dist-info/RECORD,,