qprogram-qdac 0.1.0__py3-none-any.whl

qprogram_qdac/__init__.py

@@ -0,0 +1,140 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""QDAC vendor extensions for QProgram.
+
+This package provides three things:
+
+1. **Runtime registration.** Importing the package is the activation step. It registers the ``qdac``
+   vendor namespace on [`QProgram`][qprogram.QProgram], every QDAC operation with the ``.qp``
+   serializer, and the ``qdac-default-v1`` capability profile.
+2. **Typed mixin.** [`QdacMixin`][qprogram_qdac.QdacMixin] declares a typed ``.qdac`` property for editor autocomplete.
+3. **Pre-combined builder.** [`QProgram`][qprogram_qdac.QProgram] here is [`qprogram.QProgram`][] with that mixin
+   already applied.
+
+A ``.qp`` file whose header says ``require qdac 0.1`` activates the package on load even when the
+caller never imported it. `qprogram.loads` looks the vendor up in the ``qprogram.vendors``
+entry-point group declared in ``pyproject.toml`` and imports this module for its side effects.
+
+QDAC is a slow high-precision DAC, most often used for flux biasing on transmon platforms. The
+operations it contributes are:
+
+- [`QdacNamespace.play`][qprogram_qdac.QdacNamespace.play], which uploads an envelope to one channel's waveform engine;
+- [`QdacNamespace.set_trigger`][qprogram_qdac.QdacNamespace.set_trigger] and
+  [`QdacNamespace.wait_trigger`][qprogram_qdac.QdacNamespace.wait_trigger], the trigger-network plumbing that lines a
+  QDAC sequence up with another instrument;
+- [`QdacNamespace.set_offset`][qprogram_qdac.QdacNamespace.set_offset], a DC offset whose swept form lifts the enclosing
+  loop to host-side dispatch.
+
+Usage, with the pre-combined builder::
+
+    from qprogram.waveforms import Ramp
+    from qprogram_qdac import QProgram
+
+    qp = QProgram(label="flux-sweep")
+    qp.qdac.set_offset("flux_q0", 0.42)
+    qp.qdac.set_trigger("flux_q0", 50, position="start", outputs={1, 2})
+    qp.qdac.play("flux_q0", Ramp(0.0, 1.0, 1000), dwell=10)
+    qp.qdac.wait_trigger("flux_q0", port=3)
+
+That program serializes to::
+
+    #!QProgram 1.0
+
+    require qdac 0.1
+
+    metadata:
+      label: "flux-sweep"
+
+    body:
+      qdac.set_offset "flux_q0" 0.42
+      qdac.set_trigger "flux_q0" 50 outputs=[1, 2]
+      qdac.play "flux_q0" Ramp(from_amplitude=0.0, to_amplitude=1.0, duration=1000) dwell=10
+      qdac.wait_trigger "flux_q0" 3
+
+Usage, with several vendors combined::
+
+    from qprogram import QProgram as BaseQProgram
+    from qprogram_qblox import QbloxMixin
+    from qprogram_qdac import QdacMixin
+
+
+    class QProgram(QbloxMixin, QdacMixin, BaseQProgram):
+        pass
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from qprogram.qprogram import QProgram as _BaseQProgram
+from qprogram.serialization.registry import (
+    register_vendor_operation,
+    register_vendor_version,
+)
+
+from qprogram_qdac.mixin import QdacMixin
+from qprogram_qdac.namespace import QdacNamespace
+from qprogram_qdac.operations import (
+    Play,
+    SetOffset,
+    SetTrigger,
+    WaitTrigger,
+)
+from qprogram_qdac.profiles import QDAC_DEFAULT_V1
+from qprogram_qdac.profiles import _register as _register_qdac_profile
+
+# The installed distribution version is the single source of truth for the qdac vendor protocol
+# version: the parser checks a file's ``require qdac <major.minor>`` against it.
+try:
+    __version__ = version("qprogram-qdac")
+except PackageNotFoundError:  # pragma: no cover - source tree without installed metadata
+    __version__ = "0.0.0"
+
+# Registering on the base class rather than on this package's QProgram is what makes
+# ``program.qdac.<operation>()`` work on any program, mixin or no mixin.
+_BaseQProgram.register_vendor("qdac", QdacNamespace)
+
+register_vendor_version("qdac", __version__)
+
+# Every operation takes the default signature-driven serialize / parse pair. SetTrigger's
+# ``outputs`` tuple goes through the writer's generic sequence branch (``outputs=[1, 2, 3]``), the
+# parser's bracket-aware tokenizer keeps that literal whole, and ``_normalize_outputs`` turns the
+# reloaded list back into the canonical sorted tuple.
+register_vendor_operation("qdac", "wait_trigger", WaitTrigger)
+register_vendor_operation("qdac", "set_trigger", SetTrigger)
+register_vendor_operation("qdac", "set_offset", SetOffset)
+register_vendor_operation("qdac", "play", Play)
+
+# Importing qprogram_qdac.profiles above already registered the vendor capability tokens, which the
+# profile names, so the profile passes token validation here.
+_register_qdac_profile()
+
+
+class QProgram(QdacMixin, _BaseQProgram):
+    """[`QProgram`][qprogram.QProgram] pre-combined with [`QdacMixin`][qprogram_qdac.QdacMixin].
+
+    Behaves exactly like [`qprogram.QProgram`][], with editor autocomplete for ``qp.qdac.*``.
+    """
+
+
+__all__ = [
+    "QDAC_DEFAULT_V1",
+    "Play",
+    "QProgram",
+    "QdacMixin",
+    "QdacNamespace",
+    "SetOffset",
+    "SetTrigger",
+    "WaitTrigger",
+]

qprogram_qdac/mixin.py

@@ -0,0 +1,71 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""The typed mixin that spells ``.qdac`` out on a QProgram subclass.
+
+The mixin exists for editor support and nothing else. At runtime the base
+[`QProgram`][qprogram.QProgram]'s dynamic ``__getattr__`` already routes ``program.qdac.*`` to the
+registered [`QdacNamespace`][qprogram_qdac.QdacNamespace]. Type checkers and editors cannot see
+that dispatch, so the mixin declares the namespace as a typed ``@property``.
+
+Usage, one vendor::
+
+    from qprogram_qdac import QProgram
+
+    qp = QProgram()
+    qp.qdac.set_offset("flux_q0", 0.42)
+
+Usage, several vendors combined by a platform::
+
+    from qprogram import QProgram as BaseQProgram
+    from qprogram_qblox import QbloxMixin
+    from qprogram_qdac import QdacMixin
+
+
+    class QProgram(QbloxMixin, QdacMixin, BaseQProgram):
+        pass
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qprogram_qdac.namespace import QdacNamespace
+
+if TYPE_CHECKING:
+    from qprogram.qprogram import QProgram as _BaseQProgram
+
+
+class QdacMixin:
+    """Mixin that adds a typed ``.qdac`` property to a QProgram subclass.
+
+    Combine it with [`qprogram.QProgram`][] through multiple inheritance, listing one mixin per
+    vendor. [`qprogram_qdac.QProgram`][] is that combination already made.
+    """
+
+    @property
+    def qdac(self: _BaseQProgram) -> QdacNamespace:  # type: ignore[misc]
+        """This program's typed QDAC namespace.
+
+        The first access builds a [`QdacNamespace`][qprogram_qdac.QdacNamespace] bound to the program and stores it on
+        the instance, so every later access hands back the same object.
+        """
+        # Reading and writing the cache through ``object`` keeps it clear of any attribute hooks
+        # a QProgram subclass installs, and of the vendor lookup in ``QProgram.__getattr__``.
+        try:
+            return object.__getattribute__(self, "_qdac_ns")  # ruff: ignore[unnecessary-dunder-call]
+        except AttributeError:
+            pass
+        ns = QdacNamespace(self)
+        object.__setattr__(self, "_qdac_ns", ns)  # ruff: ignore[unnecessary-dunder-call]
+        return ns

qprogram_qdac/namespace.py

@@ -0,0 +1,137 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""The typed [`VendorNamespace`][qprogram.VendorNamespace] for QDAC operations.
+
+Every method on [`QdacNamespace`][qprogram_qdac.QdacNamespace] constructs one
+[`Operation`][qprogram.operations.Operation] subclass and appends it to the program's active block.
+The typed signatures are the discoverable surface: the dynamic ``__getattr__`` on
+[`QProgram`][qprogram.QProgram] dispatches the same calls, but says nothing about their arguments.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qprogram.vendor import VendorNamespace
+
+from qprogram_qdac.operations import (
+    Play,
+    SetOffset,
+    SetTrigger,
+    TriggerPosition,
+    WaitTrigger,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.variable import Expression
+    from qprogram.waveforms.waveform import Waveform
+
+
+class QdacNamespace(VendorNamespace):
+    """The QDAC vendor namespace, reached as ``program.qdac.<operation>()``.
+
+    Available on every [`QProgram`][qprogram.QProgram] instance once `qprogram_qdac` is imported.
+    Each method type-checks its arguments through the signature, builds the matching operation, and
+    appends it to whichever block the program has open.
+    """
+
+    def wait_trigger(self, bus: str, port: int) -> None:
+        """Append a [`WaitTrigger`][qprogram_qdac.WaitTrigger] operation.
+
+        Args:
+            bus (str): QDAC channel whose trigger input the sequencer listens on.
+            port (int): Trigger input port number on the chassis.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(WaitTrigger(bus=bus, port=port))
+
+    def set_trigger(
+        self,
+        bus: str,
+        duration: int,
+        position: TriggerPosition = "start",
+        outputs: Iterable[int] = (),
+    ) -> None:
+        """Append a [`SetTrigger`][qprogram_qdac.SetTrigger] operation.
+
+        Args:
+            bus (str): QDAC channel whose trigger outputs are being configured.
+            duration (int): Trigger-active duration in nanoseconds.
+            position (TriggerPosition): Sequence event at which the triggers fire, one of
+                ``"start"``, ``"step"``, ``"end"``, ``"end_step"``. Default ``"start"``.
+            outputs (Iterable[int]): Trigger output indices to arm. Any iterable of ints will do:
+                ``set``, ``list``, ``tuple``, generator. Empty by default, which the
+                ``qdac.empty-trigger-outputs`` predicate rejects at validation time.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(SetTrigger(bus=bus, duration=duration, position=position, outputs=outputs))
+
+    def set_offset(self, bus: str, offset: float | Expression) -> None:
+        """Append a [`SetOffset`][qprogram_qdac.SetOffset] operation.
+
+        Args:
+            bus (str): QDAC channel whose DC offset is being set.
+            offset (float | Expression): Target offset in volts. Accepts a literal or any
+                [`Expression`][qprogram.Expression], a loop-bound [`Variable`][qprogram.Variable] included.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(SetOffset(bus=bus, offset=offset))
+
+    def play(  # ruff: ignore[too-many-arguments]  bus, envelope and the engine's four timing controls
+        self,
+        bus: str,
+        waveform: Waveform,
+        dwell: int = 1,
+        delay: int = 0,
+        repetitions: int = 1,
+        stepped: bool = False,
+    ) -> None:
+        """Append a [`Play`][qprogram_qdac.Play] operation.
+
+        Args:
+            bus (str): QDAC channel that emits the waveform.
+            waveform (Waveform): Single-channel [`Waveform`][qprogram.waveforms.Waveform] to emit. A
+                ``str`` alias is accepted here too, to be resolved later by
+                [`with_waveforms`][qprogram.QProgram.with_waveforms].
+            dwell (int): Per-sample dwell time in nanoseconds. Default ``1``.
+            delay (int): Delay before the first sample, in nanoseconds. Default ``0``.
+            repetitions (int): How many times the envelope is emitted. Default ``1``.
+            stepped (bool): ``True`` for discrete-step output, ``False`` for continuous
+                interpolated output. Default ``False``.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(
+            Play(
+                bus=bus,
+                waveform=waveform,
+                dwell=dwell,
+                delay=delay,
+                repetitions=repetitions,
+                stepped=stepped,
+            ),
+        )

qprogram_qdac/operations.py

@@ -0,0 +1,213 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""The QDAC operations, as AST nodes.
+
+Each class is a concrete [`Operation`][qprogram.operations.Operation] subclass that a program holds in
+its AST. They are typed attributes plus the capability tokens those attributes require.
+
+QDAC is a slow high-precision DAC, most often used for flux biasing on transmon platforms. Its
+waveform engine emits an envelope from a programmable sequencer with explicit dwell, delay,
+repetition and stepping controls. These operations expose those controls, plus the trigger network
+the engine listens to.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Literal
+
+from qprogram.operations.operation import Operation
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.variable import Expression
+    from qprogram.waveforms.waveform import Waveform
+
+
+TriggerPosition = Literal["start", "step", "end", "end_step"]
+"""The four trigger-fire positions the QDAC sequencer recognizes.
+
+- ``"start"``: the trigger fires when the sequence begins.
+- ``"step"``: the trigger fires at the start of every step of a stepped sequence.
+- ``"end"``: the trigger fires when the sequence finishes.
+- ``"end_step"``: the trigger fires at the end of every step.
+"""
+
+
+def _normalize_outputs(value: Iterable[int] | str) -> tuple[int, ...]:
+    """Return ``value`` as a sorted tuple of unique output indices.
+
+    Accepts any iterable of integers (``set``, ``list``, ``tuple``, numpy array, ``range``,
+    generator), and the comma-separated string a hand-written ``.qp`` file may carry
+    (``outputs="1,2,3"``). Duplicates are dropped and the result is sorted, so two spellings of the
+    same set of outputs hash and compare the same. Coercion is ``int()``, so a real-numbered element
+    is truncated towards zero rather than rejected.
+
+    Args:
+        value (Iterable[int] | str): Output indices, or a comma-separated string of them.
+
+    Returns:
+        The indices as a sorted tuple, with duplicates removed.
+
+    Raises:
+        TypeError: If ``value`` is not iterable, or an element is of a type ``int()`` will not take.
+        ValueError: If a comma-separated field is not a valid integer literal.
+    """
+    if isinstance(value, str):
+        return tuple(sorted({int(p.strip()) for p in value.split(",") if p.strip()}))
+    return tuple(sorted({int(x) for x in value}))
+
+
+class WaitTrigger(Operation):
+    """A halt on a QDAC channel until an external trigger arrives on one input port.
+
+    This is how a QDAC sequence lines up with hardware on another instrument, a qblox sequencer's
+    ``set_trigger`` for instance. The QDAC sequencer stops until the trigger fires, and emits no
+    waveform while it waits.
+
+    Args:
+        bus (str): QDAC channel whose trigger input the sequencer listens on.
+        port (int): Trigger input port number on the chassis, typically 1-based.
+    """
+
+    def __init__(self, bus: str, port: int) -> None:
+        self.bus = bus
+        self.port = port
+
+    def required_capabilities(self) -> set[str]:
+        """Return the single ``vendor.qdac.wait_trigger`` token."""
+        return {"vendor.qdac.wait_trigger"}
+
+
+class SetTrigger(Operation):
+    """An arming of one or more QDAC trigger outputs at a chosen sequence position.
+
+    The QDAC chassis carries an internal trigger bus with several output lines. This operation arms
+    a subset of them to fire for ``duration`` nanoseconds at a sequence event: sequence start, every
+    step, sequence end, or every step's end.
+
+    Args:
+        bus (str): QDAC channel whose trigger outputs are being configured.
+        duration (int): Trigger-active duration in nanoseconds.
+        position (TriggerPosition): Sequence event at which the triggers fire, one of ``"start"``,
+            ``"step"``, ``"end"``, ``"end_step"``. Default ``"start"``.
+        outputs (Iterable[int] | str): Trigger output indices to arm. Any iterable of ints, or a
+            comma-separated string of them. Empty by default, which the
+            ``qdac.empty-trigger-outputs`` predicate rejects at validation time.
+
+    Attributes:
+        outputs (tuple[int, ...]): The argument as stored, sorted and deduplicated on the way in, so
+            ``{2, 1}`` and ``[1, 2, 1]`` produce equal operations.
+
+    Raises:
+        TypeError: If ``outputs`` is not iterable, or holds an element of a type ``int()`` will not
+            take.
+        ValueError: If ``outputs`` is a string whose comma-separated fields are not integers.
+    """
+
+    def __init__(
+        self,
+        bus: str,
+        duration: int,
+        position: TriggerPosition = "start",
+        outputs: Iterable[int] | str = (),
+    ) -> None:
+        self.bus = bus
+        self.duration = duration
+        self.position: TriggerPosition = position
+        self.outputs: tuple[int, ...] = _normalize_outputs(outputs)
+
+    def required_capabilities(self) -> set[str]:
+        """Return the single ``vendor.qdac.set_trigger`` token."""
+        return {"vendor.qdac.set_trigger"}
+
+
+class SetOffset(Operation):
+    """A static DC offset on a QDAC channel.
+
+    The channel holds ``offset`` volts until another operation changes it.
+
+    Args:
+        bus (str): QDAC channel whose DC offset is being set.
+        offset (float | Expression): Target offset in volts. Accepts a literal or any
+            [`Expression`][qprogram.Expression], a loop-bound [`Variable`][qprogram.Variable] included. A
+            swept offset is re-uploaded once per iteration, which is what the
+            `qprogram_qdac.profiles` constraint on the enclosing loop expresses.
+    """
+
+    def __init__(self, bus: str, offset: float | Expression) -> None:
+        self.bus = bus
+        self.offset = offset
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qdac.set_offset`` plus the tokens contributed by the ``offset`` expression."""
+        from qprogram.protocol import expression_tokens  # ruff: ignore[import-outside-top-level]
+
+        return {"vendor.qdac.set_offset"} | expression_tokens(self.offset)
+
+
+class Play(Operation):
+    """An envelope emitted from a QDAC channel's waveform engine.
+
+    The channel comes from ``bus``, so the operation routes to that bus's capability slot like every
+    other QDAC operation. The rest of the arguments are the waveform-engine program: the envelope
+    and its timing.
+
+    Args:
+        bus (str): QDAC channel that emits the waveform.
+        waveform (Waveform): Single-channel [`Waveform`][qprogram.waveforms.Waveform] whose envelope is
+            uploaded to the waveform engine. A ``str`` alias is accepted here too, to be resolved
+            later by [`with_waveforms`][qprogram.QProgram.with_waveforms].
+        dwell (int): Per-sample dwell time in nanoseconds, which sets the emission rate. Default
+            ``1``.
+        delay (int): Delay in nanoseconds between sequence start and the first sample. Default
+            ``0``.
+        repetitions (int): How many times the engine emits the envelope in total, the first
+            emission included. Default ``1``.
+        stepped (bool): ``True`` to step through the samples discretely, re-arming the DAC for each
+            one, ``False`` for continuous interpolated output. Default ``False``.
+    """
+
+    WAVEFORM_ATTRS: ClassVar[tuple[str, ...]] = ("waveform",)
+
+    def __init__(  # ruff: ignore[too-many-arguments]  bus, envelope and the engine's four timing controls
+        self,
+        bus: str,
+        waveform: Waveform,
+        dwell: int = 1,
+        delay: int = 0,
+        repetitions: int = 1,
+        stepped: bool = False,
+    ) -> None:
+        self.bus = bus
+        self.waveform = waveform
+        self.dwell = dwell
+        self.delay = delay
+        self.repetitions = repetitions
+        self.stepped = stepped
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qdac.play`` plus the tokens describing the waveform.
+
+        ``waveform.single`` is always required, since the engine drives one channel. A registered
+        waveform class contributes its per-class token from [`qprogram.protocol.waveform_token`][]
+        on top, ``waveform.ramp`` for a [`Ramp`][qprogram.waveforms.Ramp] for instance.
+        """
+        from qprogram.protocol import waveform_token  # ruff: ignore[import-outside-top-level]
+
+        caps = {"vendor.qdac.play", "waveform.single"}
+        tok = waveform_token(self.waveform)
+        if tok is not None:
+            caps.add(tok)
+        return caps

qprogram_qdac/profiles.py

@@ -0,0 +1,234 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""The capability profile bundle for the QDAC vendor extension.
+
+Ships [`QDAC_DEFAULT_V1`][qprogram_qdac.QDAC_DEFAULT_V1], the bus-level profile listing what the QDAC waveform engine
+supports on one bus (one channel). A qdac platform attaches it to the flux buses of its schema and leaves the drive and
+readout buses to another vendor, qblox for instance. The platform-level slot is filled by the core-shipped
+``qprogram-base-v1``, the same as for any other vendor.
+
+The profile carries two predicates:
+
+- A soft [`DomainConstraint`][qprogram.DomainConstraint] excluding ``"rt"``, emitted whenever a qdac operation
+  reads a loop-bound [`Variable`][qprogram.Variable]. QDAC has no FPGA, so every swept parameter (a DC
+  offset, a waveform-engine setting, a waveform's own parameters) has to be re-uploaded from the
+  host between iterations. The constraint names the enclosing loop, which the classifier drops to
+  ``{host}`` and reports as a ``forced-host`` warning quoting the constraint's reason; everything
+  outside the qdac operation is left alone.
+- A hard ``qdac.empty-trigger-outputs`` error [`Diagnostic`][qprogram.Diagnostic] for a
+  [`SetTrigger`][qprogram_qdac.SetTrigger] that arms no output.
+
+Registered as a side effect of importing `qprogram_qdac`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qprogram.protocol import (
+    Diagnostic,
+    DomainConstraint,
+    Profile,
+    ValidationContext,
+    register_capability_tokens,
+    register_profile,
+)
+
+from qprogram_qdac.operations import Play, SetOffset, SetTrigger, WaitTrigger
+
+# Register the vendor tokens *before* constructing the profile that names them:
+# Profile.__post_init__ checks every listed token against CAPABILITY_REGISTRY.
+register_capability_tokens(
+    "vendor.qdac.wait_trigger",
+    "vendor.qdac.set_trigger",
+    "vendor.qdac.set_offset",
+    "vendor.qdac.play",
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.blocks.block import Block
+    from qprogram.operations.operation import Operation
+
+
+_QDAC_OP_CLASSES: tuple[type, ...] = (WaitTrigger, SetTrigger, SetOffset, Play)
+"""Every qdac [`Operation`][qprogram.operations.Operation] subclass.
+
+`_qdac_op_with_swept_var_is_host_only` filters on it. A predicate runs on every node the
+validator visits within its slot, core operations included, so it has to recognize its own nodes
+rather than trusting routing to have done it.
+"""
+
+
+def _qdac_op_with_swept_var_is_host_only(
+    node: Operation | Block,
+    ctx: ValidationContext,
+) -> Iterable[Diagnostic | DomainConstraint]:
+    """Constrain the binding loop of any variable a qdac operation reads to host-side dispatch.
+
+    QDAC has no FPGA. Every parameter change goes through the host's slow-control plane, at
+    millisecond latency, so a qdac operation that reads a variable bound by an enclosing
+    [`Sweep`][qprogram.blocks.Sweep] cannot sit inside a real-time hardware loop. The loop has to
+    dispatch host-side and re-upload the value once per iteration.
+
+    The constraint targets the **binding loop block**, never the qdac operation, which is what the
+    spec requires and what keeps the operation's own classification untouched. What changes is the
+    loop: its support drops from rt-or-host to host only.
+
+    Variables are read off the node with [`variables`][qprogram.operations.Operation.variables], which
+    descends into expression arguments and waveform parameters. A
+    ``play(bus, Square(amplitude=v))`` is therefore caught as surely as a ``set_offset(bus, v)``.
+
+    On a platform that fills only the host half of its qdac bus slots the constraint changes
+    nothing: the operation is host-only by construction there, and op-children consensus lifts the
+    loop on its own. What the constraint covers is a platform that fills both halves, and when it
+    does fire it supplies the reason text the loop's ``forced-host`` warning quotes.
+
+    Args:
+        node (Operation | Block): The AST node currently being checked.
+        ctx (ValidationContext): Validation context, used to find the loop that binds each variable.
+
+    Yields:
+        One [`DomainConstraint`][qprogram.DomainConstraint] excluding ``"rt"`` per distinct binding loop reached
+        from ``node``. Nothing when ``node`` is not a qdac operation, or reads no bound variable.
+    """
+    if not isinstance(node, _QDAC_OP_CLASSES):
+        return
+    seen_loops: set[int] = set()
+    for var in node.variables():
+        binding_loop = ctx.binding_loop_of(var)
+        if binding_loop is None or id(binding_loop) in seen_loops:
+            continue
+        seen_loops.add(id(binding_loop))
+        yield DomainConstraint(
+            node=binding_loop,
+            exclude=frozenset({"rt"}),
+            reason=(
+                f"qdac.{type(node).__name__} references loop-bound variable {var.id!r}; "
+                f"qdac has no FPGA, so the loop must dispatch host-side."
+            ),
+        )
+
+
+def _set_trigger_outputs_required(
+    node: Operation | Block,
+    ctx: ValidationContext,  # ruff: ignore[unused-function-argument]  a purely structural check
+) -> Iterable[Diagnostic | DomainConstraint]:
+    """Reject a [`SetTrigger`][qprogram_qdac.SetTrigger] that arms no output.
+
+    A trigger with an empty ``outputs`` set fires onto nothing, which is a mistake in every domain
+    rather than something host-side dispatch could rescue. That makes it a
+    [`Diagnostic`][qprogram.Diagnostic] and not a [`DomainConstraint`][qprogram.DomainConstraint].
+
+    Args:
+        node (Operation | Block): The AST node currently being checked.
+        ctx (ValidationContext): Validation context. Unused: the check reads only the node.
+
+    Yields:
+        One ``qdac.empty-trigger-outputs`` error [`Diagnostic`][qprogram.Diagnostic] when ``node`` is a
+        ``SetTrigger`` with no outputs. Nothing otherwise.
+    """
+    if not isinstance(node, SetTrigger):
+        return
+    if not node.outputs:
+        yield Diagnostic(
+            severity="error",
+            code="qdac.empty-trigger-outputs",
+            message=(
+                "SetTrigger has no outputs configured. Specify at least one output index, e.g. "
+                "outputs={1} or outputs=[1, 2]."
+            ),
+            node=node,
+        )
+
+
+_BUS_OPS: frozenset[str] = frozenset(
+    {
+        "vendor.qdac.wait_trigger",
+        "vendor.qdac.set_trigger",
+        "vendor.qdac.set_offset",
+        "vendor.qdac.play",
+    },
+)
+"""The qdac vendor operation tokens.
+
+Every qdac operation carries a ``bus`` attribute, so it routes to the per-bus
+[`BusCapabilities`][qprogram.BusCapabilities] slot the platform attaches qdac to rather than to the
+platform-level slot.
+"""
+
+_WAVEFORMS: frozenset[str] = frozenset(
+    {
+        "waveform.single",
+        "waveform.arbitrary",
+        "waveform.chained",
+        "waveform.cosine",
+        "waveform.flat_top",
+        "waveform.gaussian",
+        "waveform.ramp",
+        "waveform.sine",
+        "waveform.square",
+        "waveform.sech",
+        "waveform.snz",
+        "waveform.tukey",
+    },
+)
+"""The single-channel waveform tokens the QDAC waveform engine renders.
+
+Waveform tokens live on the bus profile because a waveform reaches the hardware through a bus. QDAC
+drives one channel per bus, so ``waveform.iq`` and the IQ waveform classes are left out on purpose:
+a program playing an [`IQDrag`][qprogram.waveforms.IQDrag] on a qdac bus fails validation with a
+``missing-capability`` diagnostic.
+"""
+
+
+QDAC_DEFAULT_V1 = Profile(
+    name="qdac-default-v1",
+    version=(0, 1, 0),
+    extends=None,
+    capabilities=_BUS_OPS | _WAVEFORMS,
+    limits={
+        # The waveform engine has a hard floor on dwell time, below which its output interpolation
+        # breaks down. No core check reads this limit; it is published here for platforms that wire
+        # in a predicate of their own.
+        "min_dwell_ns": 100,
+    },
+    predicates=(
+        _qdac_op_with_swept_var_is_host_only,
+        _set_trigger_outputs_required,
+    ),
+    vendor_versions={"qdac": (0, 1, 0)},
+)
+"""The default QDAC bus-level capability profile.
+
+Because qdac has no FPGA, a platform fills the ``host`` half of each qdac-driven bus slot with this
+profile and leaves the ``rt`` half empty. Every qdac operation is then host-side by design, and a
+loop whose operations are all qdac classifies as host-side through op-children consensus alone. A
+platform that does fill both halves gets the same outcome for swept programs, this time from the
+profile's own [`DomainConstraint`][qprogram.DomainConstraint] predicate.
+
+The profile holds every qdac vendor token (``wait_trigger``, ``set_trigger``, ``set_offset``,
+``play``) plus the single-channel waveforms the engine renders. The platform-level slot of a qdac
+platform's [`PlatformCapabilities`][qprogram.PlatformCapabilities] uses the core-shipped ``qprogram-base-v1``
+directly: qdac has no bus-less operations, so it contributes nothing at that level.
+"""
+
+
+def _register() -> None:
+    """Idempotently register [`QDAC_DEFAULT_V1`][qprogram_qdac.QDAC_DEFAULT_V1] on the global profile registry."""
+    register_profile(QDAC_DEFAULT_V1)
+
+
+__all__ = ["QDAC_DEFAULT_V1"]

qprogram_qdac-0.1.0.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.5
+Name: qprogram-qdac
+Version: 0.1.0
+Summary: QDevil QDAC vendor extensions for the QProgram pulse-level quantum programming DSL.
+Project-URL: Homepage, https://github.com/qilimanjaro-tech/qprogram-qdac
+Project-URL: Documentation, https://qilimanjaro-tech.github.io/qprogram-qdac/
+Project-URL: Source, https://github.com/qilimanjaro-tech/qprogram-qdac
+Project-URL: Issues, https://github.com/qilimanjaro-tech/qprogram-qdac/issues
+Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: dsl,pulse programming,qdac,qdevil,qilimanjaro,quantum computing,quantum control
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Quantum Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: qprogram>=0.1.0
+Description-Content-Type: text/markdown
+
+# QProgram QDAC
+
+[![Tests](https://github.com/qilimanjaro-tech/qprogram-qdac/actions/workflows/tests.yml/badge.svg)](https://github.com/qilimanjaro-tech/qprogram-qdac/actions/workflows/tests.yml)
+[![Code Quality](https://github.com/qilimanjaro-tech/qprogram-qdac/actions/workflows/code_quality.yml/badge.svg)](https://github.com/qilimanjaro-tech/qprogram-qdac/actions/workflows/code_quality.yml)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+
+QDevil QDAC extensions for
+[QProgram](https://github.com/qilimanjaro-tech/qprogram), the pulse-level
+quantum programming DSL. The QDAC is a slow high-precision DAC, used most
+often for flux biasing.
+
+The core DSL knows nothing about any instrument. This package adds the
+`qdac` vendor namespace to it: four operations covering DC offsets, the
+waveform engine, and the chassis trigger network, a capability profile that
+says what a QDAC channel can do, and `.qp` serialization for all of it.
+Importing the package is what turns those on.
+
+## Installation
+
+```bash
+pip install qprogram-qdac
+```
+
+The only dependency is `qprogram` itself.
+
+## A first program
+
+```python
+import qprogram as qp
+from qprogram import BusSchema
+from qprogram.waveforms import IQPair, Square
+from qprogram_qdac import QProgram
+
+schema = BusSchema.flux_tunable_transmon()
+q = schema.q
+
+program = QProgram(label="flux-spectroscopy", schema=schema)
+bias = program.variable("bias", units="V")
+
+with program.sweep(bias).from_range(-0.2, 0.2, 0.01):
+    program.qdac.set_offset(q[0].flux, bias)
+    with program.average(shots=100):
+        program.play(q[0].drive, "pi_pulse")
+        program.sync([q[0].drive, q[0].readout])
+        m0 = program.measure(q[0].readout, "readout", "weights")
+
+resolved = program.with_waveforms(
+    {
+        "pi_pulse": IQPair(Square(0.5, 40), Square(0.0, 40)),
+        "readout": IQPair(Square(1.0, 2000), Square(0.0, 2000)),
+        "weights": IQPair(Square(1.0, 2000), Square(1.0, 2000)),
+    }
+)
+
+result = qp.simulate(resolved)
+data = result.get(m0)
+print(data.dims, data.shape)  # ('bias', 'IQ') (41, 2)
+```
+
+The flux bias comes from the QDAC, the drive and readout from whatever
+vendor owns those buses. One program describes both, and the nesting is
+what makes a mixed platform accept it: the bias sweep dispatches from the
+host, one upload per point, while the `average` block under it runs in the
+real-time sequencer. Flatten the two into one block and no domain runs
+both. `sync` names its buses because the argument-less form syncs every bus
+in the program, and a QDAC channel is not something a real-time barrier can
+wait on.
+
+## What you get
+
+- **Four operations under one namespace.** `set_offset` holds a DC voltage
+  on a channel, `play` uploads an envelope to the channel's waveform engine
+  with explicit dwell, delay, repetitions and stepped mode, and
+  `set_trigger` / `wait_trigger` wire the channel into the chassis trigger
+  network so QDAC sequences line up with instruments driving other buses.
+- **Host-side sweeps, declared rather than guessed.** The QDAC has no FPGA,
+  so a swept parameter has to be re-uploaded from the host between
+  iterations. The `qdac-default-v1` profile says so through a domain
+  constraint, and `qp.explain(program, capabilities)` prints the enclosing
+  loop as `[host]` instead of failing at compile time.
+- **Single-channel by declaration.** The profile lists only single-channel
+  waveform tokens. An IQ waveform on a QDAC bus is a `missing-capability`
+  error from `qp.validate`, not a runtime surprise.
+- **Serialization included.** Every operation round-trips through the `.qp`
+  text format, under a `require qdac 0.1` header line. A file that names
+  `qdac` activates this package on load through its entry point, so the
+  reader does not have to import it first.
+- **Typed access.** `QProgram` from this package is the core builder with a
+  typed `.qdac` property. `QdacMixin` composes with other vendor mixins
+  when a platform spans several instruments.
+
+## Documentation
+
+Full documentation, including the operation reference, the capability
+profile, and the generated API reference, lives at
+<https://qilimanjaro-tech.github.io/qprogram-qdac/>.
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone https://github.com/qilimanjaro-tech/qprogram-qdac
+cd qprogram-qdac
+
+uv sync --group dev                  # create .venv and install everything
+uv run pytest                        # run the test suite
+uv run ruff check .                  # lint
+uv run ruff format .                 # format
+uv run ty check                      # type-check
+uv run --group docs zensical serve   # preview the documentation
+```
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE).

qprogram_qdac-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+qprogram_qdac/__init__.py,sha256=18PQ2W9tv58qqjTws7JJNqRZ2ip55F1rlwWx-rN-tzo,5408
+qprogram_qdac/mixin.py,sha256=ULTqY8EDEUEOqvvFHPy4DlsZQd3cTT_R9e2ew-mpi_k,2693
+qprogram_qdac/namespace.py,sha256=WLPFJpBRSCxlHyEhq4dre2bhJDQWiZ6txCZSVPgGk4o,5614
+qprogram_qdac/operations.py,sha256=sNnffPNaLKRK62PTCzrIEBbfT5gWBojOj_MHuuFoshs,9078
+qprogram_qdac/profiles.py,sha256=8rd0GEwzpYM67v85YU6TIPhQqnKsEYp5bh4VBb2J1zg,9783
+qprogram_qdac/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qprogram_qdac-0.1.0.dist-info/METADATA,sha256=91E2nz_aBQ9hw4uv3Gx01bZUmMvCMPyP-nt6Cbdd1e0,6374
+qprogram_qdac-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+qprogram_qdac-0.1.0.dist-info/entry_points.txt,sha256=80U8nhMlMenZhw4rw7umW9yH4wuUe8SsmXb0JC5wmCA,40
+qprogram_qdac-0.1.0.dist-info/licenses/LICENSE,sha256=SSd4NLHKeN_X9uu9A5TnY3vpro7w7I9ZduIIsjtIBlo,11354
+qprogram_qdac-0.1.0.dist-info/RECORD,,

qprogram_qdac-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

qprogram_qdac-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[qprogram.vendors]
+qdac = qprogram_qdac

qprogram_qdac-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Qilimanjaro Quantum Tech
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   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.