qprogram-qblox 0.1.0__py3-none-any.whl

qprogram_qblox/__init__.py

@@ -0,0 +1,162 @@
+# 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.
+"""Qblox vendor extensions for QProgram.
+
+This package provides:
+
+1. **Runtime registration**: importing this package registers the ``qblox`` vendor namespace on
+   [`QProgram`][qprogram.QProgram], registers every Qblox operation with the ``.qp`` serializer, and
+   registers the ``qblox-default-v1`` capability profile.
+
+2. **Typed mixin**: [`QbloxMixin`][qprogram_qblox.QbloxMixin] adds a typed ``.qblox`` property for IDE autocomplete.
+
+3. **Pre-combined QProgram**: [`QProgram`][qprogram_qblox.QProgram] from this package has ``.qblox`` typed out of the
+   box.
+
+The import is the activation step, and a caller reading a ``.qp`` file need not perform it: the
+``qprogram.vendors`` entry point this package declares lets `qprogram.loads` import the module
+on demand when it meets a ``require qblox`` header.
+
+The operations span both kinds a vendor extension can offer, since QProgram draws no line between
+real-time and host-side execution:
+
+- one-to-one sequencer instructions ([`QbloxNamespace.acquire`][qprogram_qblox.QbloxNamespace.acquire],
+  [`QbloxNamespace.set_markers`][qprogram_qblox.QbloxNamespace.set_markers],
+  [`QbloxNamespace.set_trigger`][qprogram_qblox.QbloxNamespace.set_trigger],
+  [`QbloxNamespace.wait_trigger`][qprogram_qblox.QbloxNamespace.wait_trigger]);
+- host-side-only operations
+  ([`QbloxNamespace.set_acquisition_threshold`][qprogram_qblox.QbloxNamespace.set_acquisition_threshold],
+  [`QbloxNamespace.set_acquisition_rotation`][qprogram_qblox.QbloxNamespace.set_acquisition_rotation]), each a
+  slow-control parameter write at execution time rather than a sequencer instruction.
+
+Both spell the same way in ``.qp`` (``qblox.<op_name> <args>``); the platform decides at execution
+time how to realize each one. A third kind is possible and is not among the operations here: an
+orchestration that lowers to several instructions. Routing a measurement result back to a drive
+sequencer, for instance, is a property of the platform wiring rather than of the qblox instrument
+API, so it belongs to a platform package instead.
+
+The shortest way in is the pre-combined class::
+
+    from qprogram_qblox import QProgram
+
+    qp = QProgram(label="example")
+    qp.qblox.acquire("readout_q0", "weights")
+    qp.qblox.set_markers("drive_q0", "0001")
+    qp.qblox.set_acquisition_threshold("readout_q0", value=0.42)
+    qp.qblox.set_acquisition_rotation("readout_q0", angle=0.7854)
+
+Combining several vendors means listing their mixins in the MRO::
+
+    from qprogram import QProgram as BaseQProgram
+    from qprogram_qblox import QbloxMixin
+    from qprogram_qdac import QdacMixin
+
+
+    class QProgram(QbloxMixin, QdacMixin, BaseQProgram):
+        pass
+
+
+    qp = QProgram()
+    qp.qblox.acquire(...)
+    qp.qdac.play(...)
+
+A ``.qp`` file carrying qblox operations names the vendor in its header::
+
+    #!QProgram 1.0
+
+    require qblox 0.1
+
+    body:
+      qblox.acquire "readout_q0" "weights"
+      qblox.set_markers "drive_q0" "0001"
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from qprogram.qprogram import QProgram as _BaseQProgram
+from qprogram.serialization._specs import make_measurement_op_parse, measurement_op_serialize
+from qprogram.serialization.registry import register_vendor_operation, register_vendor_version
+
+from qprogram_qblox.mixin import QbloxMixin
+from qprogram_qblox.namespace import QbloxNamespace
+from qprogram_qblox.operations import (
+    Acquire,
+    SetAcquisitionRotation,
+    SetAcquisitionThreshold,
+    SetMarkers,
+    SetTrigger,
+    WaitTrigger,
+)
+from qprogram_qblox.profiles import QBLOX_DEFAULT_V1
+from qprogram_qblox.profiles import _register as _register_qblox_profile
+
+# Resolve our own package version once. This is the single source of truth for the qblox vendor
+# protocol version: parsers check that a file's `require qblox <major.minor>` is compatible with
+# this number.
+try:
+    __version__ = version("qprogram-qblox")
+except PackageNotFoundError:  # pragma: no cover - source tree without installed metadata
+    __version__ = "0.0.0"
+
+# --- Step 1: Register the vendor namespace on base QProgram ---
+# Registering on the base class is what makes program.qblox.<method>() work on any QProgram
+# instance, mixin or not.
+_BaseQProgram.register_vendor("qblox", QbloxNamespace)
+
+# --- Step 2: Register the protocol version of this vendor extension ---
+# The .qp parser checks `require qblox <x.y>` against it.
+register_vendor_version("qblox", __version__)
+
+# --- Step 3: Register operations with the .qp serializer ---
+# All but `acquire` use the default signature-driven serialize/parse pair. `acquire` is a
+# measurement operation, so it needs the measurement callbacks that carry the handle name across
+# the wire as a `name="..."` kwarg.
+register_vendor_operation(
+    "qblox",
+    "acquire",
+    Acquire,
+    serialize=measurement_op_serialize,
+    parse=make_measurement_op_parse(Acquire),
+)
+register_vendor_operation("qblox", "set_markers", SetMarkers)
+register_vendor_operation("qblox", "set_trigger", SetTrigger)
+register_vendor_operation("qblox", "wait_trigger", WaitTrigger)
+register_vendor_operation("qblox", "set_acquisition_threshold", SetAcquisitionThreshold)
+register_vendor_operation("qblox", "set_acquisition_rotation", SetAcquisitionRotation)
+
+# --- Step 4: Register the qblox capability profile bundle ---
+# Importing qprogram_qblox.profiles above already registered the vendor capability tokens, which is
+# what lets the profile name them.
+_register_qblox_profile()
+
+
+class QProgram(QbloxMixin, _BaseQProgram):
+    """[`QProgram`][qprogram.QProgram] pre-combined with [`QbloxMixin`][qprogram_qblox.QbloxMixin].
+
+    Identical to [`qprogram.QProgram`][] but with IDE autocomplete for ``qp.qblox.*``.
+    """
+
+
+__all__ = [
+    "QBLOX_DEFAULT_V1",
+    "Acquire",
+    "QProgram",
+    "QbloxMixin",
+    "QbloxNamespace",
+    "SetAcquisitionRotation",
+    "SetAcquisitionThreshold",
+    "SetMarkers",
+    "SetTrigger",
+    "WaitTrigger",
+]

qprogram_qblox/mixin.py

@@ -0,0 +1,73 @@
+# 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.
+"""Typed mixin that exposes the Qblox namespace as ``.qblox`` on a QProgram subclass.
+
+The mixin exists for the benefit of editors and type-checkers. At runtime the base
+[`QProgram`][qprogram.QProgram]'s dynamic ``__getattr__`` already routes ``program.qblox.*`` to the
+registered [`QbloxNamespace`][qprogram_qblox.QbloxNamespace], but static tooling cannot see that
+dispatch, so the mixin spells the namespace out as a typed ``@property``.
+
+One vendor, using the pre-combined class this package ships::
+
+    from qprogram_qblox import QProgram
+
+    qp = QProgram()  # QProgram with .qblox typed
+    qp.qblox.acquire(...)  # IDE autocomplete works
+
+Several vendors, composed by listing their mixins in the MRO::
+
+    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_qblox.namespace import QbloxNamespace
+
+if TYPE_CHECKING:
+    from qprogram.qprogram import QProgram as _BaseQProgram
+
+
+class QbloxMixin:
+    """Mixin that adds a typed ``.qblox`` property to QProgram.
+
+    Compose it with [`qprogram.QProgram`][] through multiple inheritance to get editor
+    autocomplete for the Qblox operations. The property caches the namespace on the program, so
+    repeated ``program.qblox`` accesses return the same object.
+    """
+
+    @property
+    def qblox(self: _BaseQProgram) -> QbloxNamespace:  # type: ignore[misc]
+        """This program's typed Qblox namespace.
+
+        The first access builds a [`QbloxNamespace`][qprogram_qblox.QbloxNamespace] bound to the
+        program and stores it under a private attribute; later accesses return that same instance.
+        Both the load and the store go through `object` so they bypass the program's own
+        attribute hooks: a cache miss has to surface as a plain `AttributeError` here rather
+        than reach [`QProgram`][qprogram.QProgram]'s vendor-registry ``__getattr__``.
+        """
+        try:
+            return object.__getattribute__(self, "_qblox_ns")  # ruff: ignore[unnecessary-dunder-call]
+        except AttributeError:
+            pass
+        ns = QbloxNamespace(self)
+        object.__setattr__(self, "_qblox_ns", ns)  # ruff: ignore[unnecessary-dunder-call]
+        return ns

qprogram_qblox/namespace.py

@@ -0,0 +1,187 @@
+# 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.
+"""Typed [`VendorNamespace`][qprogram.VendorNamespace] for Qblox operations.
+
+Each method on [`QbloxNamespace`][qprogram_qblox.QbloxNamespace] is a typed wrapper that builds the matching
+[`Operation`][qprogram.operations.Operation] subclass from `qprogram_qblox.operations` and appends
+it to the program's active block. This is where explicit parameter types live, so editors complete
+and type-checkers check ``program.qblox.<operation>(...)``. The dynamic ``__getattr__`` on
+[`QProgram`][qprogram.QProgram] dispatches the same calls at runtime; the typed namespace is what makes
+them discoverable.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qprogram.operations.operation import MeasurementField
+from qprogram.vendor import VendorNamespace
+
+from qprogram_qblox.operations import (
+    Acquire,
+    SetAcquisitionRotation,
+    SetAcquisitionThreshold,
+    SetMarkers,
+    SetTrigger,
+    WaitTrigger,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.result import MeasurementHandle
+    from qprogram.variable import Expression
+    from qprogram.waveforms.waveform import IQWaveform
+
+
+class QbloxNamespace(VendorNamespace):
+    """Qblox vendor namespace, reached as ``program.qblox.<operation>()``.
+
+    Attached to every [`QProgram`][qprogram.QProgram] instance as ``.qblox`` once the
+    `qprogram_qblox` package is imported. Each method validates its arguments through the typed
+    signature, constructs the matching operation, and appends it to the program's currently active
+    block.
+    """
+
+    def acquire(
+        self,
+        bus: str,
+        weights: IQWaveform | str,
+        fields: Iterable[MeasurementField] = (MeasurementField.IQ,),
+        *,
+        name: str | None = None,
+    ) -> MeasurementHandle:
+        """Append an [`Acquire`][qprogram_qblox.Acquire] operation.
+
+        The handle's name comes from the same per-bus counter core
+        [`measure`][qprogram.QProgram.measure] draws on, so two acquisitions on ``q[0].readout`` produce
+        ``q0/readout/m0`` and ``q0/readout/m1`` whether or not a core ``measure`` also runs on that
+        qubit. A raw-string bus carries no coordinates to build that prefix from, so it falls back
+        to the bare ``m0``, ``m1``, ... counter shared by every raw-string measurement.
+
+        Args:
+            bus (str): Readout bus to acquire on.
+            weights (IQWaveform | str): Integration weights, either a concrete
+                [`IQWaveform`][qprogram.waveforms.IQWaveform] or a string alias.
+            fields (Iterable[MeasurementField]): Which measurement fields to produce, as an iterable
+                of [`MeasurementField`][qprogram.MeasurementField] members. Default ``(MeasurementField.IQ,)``;
+                `RAW` asks for the raw ADC trace.
+            name (str | None): Explicit measurement name. Auto-allocated when omitted.
+
+        Returns:
+            The [`MeasurementHandle`][qprogram.MeasurementHandle] this acquisition writes to, for retrieving the
+            result and for referencing the outcome in a conditional.
+
+        Raises:
+            ValidationError: If ``name`` is empty, is not a string, or is already used by another
+                measurement in the program, if ``fields`` names a field that is not registered, or
+                if ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the one attached
+                to the program.
+        """
+        return self._append_measurement(
+            Acquire,
+            bus=bus,
+            weights=weights,
+            fields=fields,
+            name=name,
+        )
+
+    def set_markers(self, bus: str, mask: str) -> None:
+        """Append a [`SetMarkers`][qprogram_qblox.SetMarkers] operation.
+
+        Args:
+            bus (str): Bus whose marker outputs to drive.
+            mask (str): Four characters of ``0`` and ``1``, one per marker line, e.g. ``"0001"``.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(SetMarkers(bus=bus, mask=mask))
+
+    def set_trigger(
+        self,
+        bus: str,
+        duration: int,
+        outputs: list[int] | int | None = None,
+        position: str = "start",
+    ) -> None:
+        """Append a [`SetTrigger`][qprogram_qblox.SetTrigger] operation.
+
+        Args:
+            bus (str): Bus whose trigger outputs to arm.
+            duration (int): Trigger-active duration in nanoseconds.
+            outputs (list[int] | int | None): Trigger output indices to arm, one index or a list of
+                them. ``None`` leaves the selection to the platform.
+            position (str): Point in the operation at which the trigger fires, either ``"start"`` or
+                ``"end"``. Default ``"start"``.
+
+        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, outputs=outputs, position=position))
+
+    def wait_trigger(self, bus: str, duration: int, port: int | None = None) -> None:
+        """Append a [`WaitTrigger`][qprogram_qblox.WaitTrigger] operation.
+
+        Args:
+            bus (str): Bus whose sequencer waits.
+            duration (int): Timeout in nanoseconds, after which the sequencer stops waiting.
+            port (int | None): Trigger input port to listen on. ``None`` leaves the choice to the
+                platform.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(WaitTrigger(bus=bus, duration=duration, port=port))
+
+    def set_acquisition_threshold(self, bus: str, value: float | Expression) -> None:
+        """Append a [`SetAcquisitionThreshold`][qprogram_qblox.SetAcquisitionThreshold] operation.
+
+        Host-side-only: the platform realizes it as a slow-control parameter write at execution
+        time, not as a sequencer instruction. A vendor namespace can expose operations whose effect
+        is entirely off-sequencer, and the platform decides at execution time how to realize each
+        one.
+
+        Args:
+            bus (str): Readout bus whose discrimination threshold to set.
+            value (float | Expression): Threshold, in volts after integration. Accepts an
+                [`Expression`][qprogram.Expression] so an enclosing loop can sweep it.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(SetAcquisitionThreshold(bus=bus, value=value))
+
+    def set_acquisition_rotation(self, bus: str, angle: float | Expression) -> None:
+        """Append a [`SetAcquisitionRotation`][qprogram_qblox.SetAcquisitionRotation] operation.
+
+        The companion to `set_acquisition_threshold`: the integrated IQ point is rotated by
+        ``angle`` before the comparison against the threshold, so the two populations separate along
+        one axis. Host-side-only as well, a parameter write rather than a sequencer instruction.
+
+        Args:
+            bus (str): Readout bus whose acquisition rotation to set.
+            angle (float | Expression): Rotation angle in radians, the unit convention of core
+                [`set_phase`][qprogram.QProgram.set_phase]. Accepts an [`Expression`][qprogram.Expression] so an
+                enclosing loop can sweep it, which is how it is normally calibrated.
+
+        Raises:
+            ValidationError: If ``bus`` is a [`BusRef`][qprogram.BusRef] from another schema than the
+                one attached to the program.
+        """
+        self._append(SetAcquisitionRotation(bus=bus, angle=angle))

qprogram_qblox/operations.py

@@ -0,0 +1,233 @@
+# 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.
+"""Qblox-specific Operation classes.
+
+Each class is a concrete [`Operation`][qprogram.operations.Operation] subclass that lives in the QProgram
+AST. They are the data nodes: typed attributes plus the capability tokens they require, serialized
+to and from ``.qp`` by the vendor registry.
+
+They span both kinds of vendor operation. [`Acquire`][qprogram_qblox.Acquire],
+[`SetMarkers`][qprogram_qblox.SetMarkers], [`SetTrigger`][qprogram_qblox.SetTrigger] and
+[`WaitTrigger`][qprogram_qblox.WaitTrigger] each map to one sequencer instruction;
+[`SetAcquisitionThreshold`][qprogram_qblox.SetAcquisitionThreshold] and
+[`SetAcquisitionRotation`][qprogram_qblox.SetAcquisitionRotation] map to no sequencer instruction at all and are
+realized as slow-control parameter writes. The AST draws no distinction between the two, and neither does the ``.qp``
+format.
+
+A class declares `BUS_ATTRS` and
+`WAVEFORM_ATTRS` only where its data shape differs from the
+``Operation`` defaults. The base class's introspection methods (``variables``, ``buses``,
+``waveforms``, ``walk``) read those declarations, so no subclass here overrides them.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from qprogram.operations.operation import MeasurementField, MeasurementOperation, Operation, normalize_fields
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.result import MeasurementHandle
+    from qprogram.variable import Expression
+    from qprogram.waveforms.waveform import IQWaveform
+
+
+class Acquire(MeasurementOperation):
+    """An acquisition on a readout bus, with no readout pulse of its own.
+
+    Where core ``measure`` plays a readout pulse and integrates the response, ``acquire`` only
+    integrates, which is what a program wants when the pulse is driven separately. It is a
+    [`MeasurementOperation`][qprogram.operations.operation.MeasurementOperation] like ``measure``, so it takes part
+    in the program's per-bus measurement-name counter: an ``acquire`` after a ``measure`` on the same
+    qubit picks up the next free name on that qubit.
+
+    Args:
+        bus (str): Readout bus to acquire on.
+        weights (IQWaveform | str): Integration weights, either a concrete
+            [`IQWaveform`][qprogram.waveforms.IQWaveform] or a string alias resolved later by
+            [`with_waveforms`][qprogram.QProgram.with_waveforms].
+        handle (MeasurementHandle): The canonical [`MeasurementHandle`][qprogram.MeasurementHandle] for this
+            acquisition. See [`Measure`][qprogram.operations.Measure] for what the runtime writes onto
+            it and who reads it.
+        fields (Iterable[MeasurementField]): Which measurement fields the platform produces, as an
+            iterable of [`MeasurementField`][qprogram.MeasurementField] members. Default
+            ``(MeasurementField.IQ,)``. See [`Measure`][qprogram.operations.Measure] for the full
+            description. Stored canonically ordered and deduplicated by
+            [`normalize_fields`][qprogram.operations.operation.normalize_fields].
+
+    Raises:
+        ValidationError: If ``fields`` is a bare string, is not iterable, requests no field at all,
+            or names a field that is not registered.
+    """
+
+    WAVEFORM_ATTRS: ClassVar[tuple[str, ...]] = ("weights",)
+
+    def __init__(
+        self,
+        bus: str,
+        weights: IQWaveform | str,
+        handle: MeasurementHandle,
+        fields: Iterable[MeasurementField] = (MeasurementField.IQ,),
+    ) -> None:
+        self.bus = bus
+        self.weights = weights
+        self.handle = handle
+        self.fields: tuple[str, ...] = normalize_fields(fields)
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.acquire`` plus the weights and requested-field tokens.
+
+        ``waveform.iq`` is always required, since an acquisition integrates an IQ pair. String
+        weights contribute ``waveform.alias``; concrete weights contribute the per-class token from
+        [`qprogram.protocol.waveform_token`][] when their class is registered. The
+        ``measure.fields.<name>`` tokens come from
+        [`required_capabilities`][qprogram.operations.operation.MeasurementOperation.required_capabilities].
+        """
+        from qprogram.protocol import waveform_token  # ruff: ignore[import-outside-top-level]
+
+        caps = super().required_capabilities() | {"vendor.qblox.acquire", "waveform.iq"}
+        if isinstance(self.weights, str):
+            caps.add("waveform.alias")
+        else:
+            tok = waveform_token(self.weights)
+            if tok is not None:
+                caps.add(tok)
+        return caps
+
+
+class SetMarkers(Operation):
+    """A new 4-bit marker output mask on a qblox sequencer.
+
+    Args:
+        bus (str): Bus whose marker outputs to drive.
+        mask (str): Four characters of ``0`` and ``1``, one per marker line. ``"0001"`` enables
+            marker 1.
+    """
+
+    def __init__(self, bus: str, mask: str) -> None:
+        self.bus = bus
+        self.mask = mask
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.set_markers``, the operation's identity token."""
+        return {"vendor.qblox.set_markers"}
+
+
+class SetTrigger(Operation):
+    """A trigger output configuration on a qblox sequencer.
+
+    Args:
+        bus (str): Bus whose trigger outputs to arm.
+        duration (int): Trigger-active duration in nanoseconds.
+        outputs (list[int] | int | None): Trigger output indices to arm, one index or a list of
+            them. ``None`` leaves the selection to the platform.
+        position (str): Point in the operation at which the trigger fires, either ``"start"`` or
+            ``"end"``. Default ``"start"``.
+    """
+
+    def __init__(
+        self,
+        bus: str,
+        duration: int,
+        outputs: list[int] | int | None = None,
+        position: str = "start",
+    ) -> None:
+        self.bus = bus
+        self.duration = duration
+        self.outputs = outputs
+        self.position = position
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.set_trigger``, the operation's identity token."""
+        return {"vendor.qblox.set_trigger"}
+
+
+class WaitTrigger(Operation):
+    """A wait for an external trigger on a qblox sequencer.
+
+    Args:
+        bus (str): Bus whose sequencer waits.
+        duration (int): Timeout in nanoseconds, after which the sequencer stops waiting.
+        port (int | None): Trigger input port to listen on. ``None`` leaves the choice to the
+            platform.
+    """
+
+    def __init__(self, bus: str, duration: int, port: int | None = None) -> None:
+        self.bus = bus
+        self.duration = duration
+        self.port = port
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.wait_trigger``, the operation's identity token."""
+        return {"vendor.qblox.wait_trigger"}
+
+
+class SetAcquisitionThreshold(Operation):
+    """A new qubit-state discrimination threshold on a readout bus.
+
+    A **host-side-only** vendor operation: the qblox platform realizes it as a slow-control
+    parameter write at execution time and emits no sequencer instruction. Vendor operations do not
+    have to map onto sequencer instructions at all: an extension may expose any operation whose
+    execution its platform knows how to interpret, be that a sequencer command, a parameter write,
+    or a multi-step orchestration.
+
+    Args:
+        bus (str): Readout bus whose discrimination threshold to set.
+        value (float | Expression): Threshold, in volts after integration. Accepts an
+            [`Expression`][qprogram.Expression] for sweeps.
+    """
+
+    def __init__(self, bus: str, value: float | Expression) -> None:
+        self.bus = bus
+        self.value = value
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.set_acquisition_threshold`` plus the ``value`` expression tokens."""
+        from qprogram.protocol import expression_tokens  # ruff: ignore[import-outside-top-level]
+
+        return {"vendor.qblox.set_acquisition_threshold"} | expression_tokens(self.value)
+
+
+class SetAcquisitionRotation(Operation):
+    """A new acquisition rotation angle on a readout bus.
+
+    The other half of qblox's thresholded acquisition, and the sibling of
+    [`SetAcquisitionThreshold`][qprogram_qblox.SetAcquisitionThreshold]: the integrated IQ point is rotated by this
+    angle so that the ground and excited populations separate along a single axis, and only then compared against the
+    threshold. Setting one without the other is legal, since they are independent parameters, but a calibrated
+    discrimination usually writes both.
+
+    Host-side-only like the threshold: a slow-control parameter write at execution time, not a
+    sequencer instruction.
+
+    Args:
+        bus (str): Readout bus whose acquisition rotation to set.
+        angle (float | Expression): Rotation angle in **radians**, the unit convention of the core
+            phase operations ([`SetPhase`][qprogram.operations.SetPhase]). Accepts an
+            [`Expression`][qprogram.Expression] for sweeps, which is the usual way to calibrate it. Values
+            outside ``[0, 2π)`` are the platform's to normalize or reject, not this node's: a swept
+            angle has no literal value to check at build time.
+    """
+
+    def __init__(self, bus: str, angle: float | Expression) -> None:
+        self.bus = bus
+        self.angle = angle
+
+    def required_capabilities(self) -> set[str]:
+        """Return ``vendor.qblox.set_acquisition_rotation`` plus the ``angle`` expression tokens."""
+        from qprogram.protocol import expression_tokens  # ruff: ignore[import-outside-top-level]
+
+        return {"vendor.qblox.set_acquisition_rotation"} | expression_tokens(self.angle)

qprogram_qblox/profiles.py

@@ -0,0 +1,271 @@
+# 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.
+"""Capability profile bundles for the Qblox vendor extension.
+
+Defines [`QBLOX_DEFAULT_V1`][qprogram_qblox.QBLOX_DEFAULT_V1], the bus-level profile describing what a qblox-driven bus
+can do: the pulse, timing and parameter operations, every waveform class the sequencers render, the measurement fields a
+readout produces, and the ``vendor.qblox.*`` operations. Qblox drives its sequencers in real time, so a platform fills a
+bus slot's ``rt`` half with it; the platform slot is filled by the core-shipped ``qprogram-base-v1``, which carries the
+block, sweep and expression tokens. Together the two give a complete
+[`PlatformCapabilities`][qprogram.PlatformCapabilities] shape.
+
+Two predicates travel with the profile:
+
+- `_reject_arbitrary_sweep_at_wait_duration`, a hard [`Diagnostic`][qprogram.Diagnostic]. The
+  operand register of the qblox wait instruction advances by a fixed step, so a duration swept from
+  an arbitrary source fits no execution model qblox can compile, real-time or host-side.
+- `_drag_sigma_in_loop_is_host_only`, a soft [`DomainConstraint`][qprogram.DomainConstraint]. The
+  sequencer cannot recompute an [`IQDrag`][qprogram.waveforms.IQDrag] envelope between iterations, but
+  the host can dispatch one shot per iteration. The constraint excludes ``"rt"`` alone, so the
+  binding loop classifies as ``{host}`` while the ``play`` inside it stays real-time.
+
+Registered as a side effect of importing `qprogram_qblox`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qprogram.operations.play import Play
+from qprogram.operations.wait import Wait
+from qprogram.protocol import (
+    Diagnostic,
+    DomainConstraint,
+    Profile,
+    ValidationContext,
+    register_capability_tokens,
+    register_profile,
+)
+from qprogram.variable import Variable
+from qprogram.waveforms.iq_drag import IQDrag
+
+# Register vendor-specific capability tokens *before* constructing the profile that names them:
+# Profile.__post_init__ validates that every listed token is in CAPABILITY_REGISTRY, so registration
+# must come first.
+register_capability_tokens(
+    "vendor.qblox.acquire",
+    "vendor.qblox.set_markers",
+    "vendor.qblox.set_trigger",
+    "vendor.qblox.wait_trigger",
+    "vendor.qblox.set_acquisition_threshold",
+    "vendor.qblox.set_acquisition_rotation",
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from qprogram.blocks.block import Block
+    from qprogram.operations.operation import Operation
+
+
+def _reject_arbitrary_sweep_at_wait_duration(
+    node: Operation | Block,
+    ctx: ValidationContext,
+) -> Iterable[Diagnostic | DomainConstraint]:
+    """Reject a ``wait`` whose duration is bound to an arbitrary sweep source.
+
+    The qblox wait instruction takes one integer cycle count, and the register holding it advances
+    by a fixed step, so the hardware can only walk a duration that is an exact ``start + step * i``
+    ramp. The predicate asks [`sweep_kind_of`][qprogram.ValidationContext.sweep_kind_of] how the variable at
+    `duration` is bound and fires when the binding
+    [`Sweep`][qprogram.blocks.Sweep]'s source declares ``KIND = "arbitrary"``:
+    [`Values`][qprogram.sweeps.Values], [`Logspace`][qprogram.sweeps.Logspace],
+    [`File`][qprogram.sweeps.File], and every combinator around them. A linear source
+    ([`Range`][qprogram.sweeps.Range], [`Linspace`][qprogram.sweeps.Linspace]) passes, and so does a
+    constant duration, which is not loop-bound at all.
+
+    Host-side dispatch cannot rescue the combination, since qblox still has to emit the wait
+    instruction per shot. That is why this is a [`Diagnostic`][qprogram.Diagnostic] rather than a
+    [`DomainConstraint`][qprogram.DomainConstraint].
+
+    Args:
+        node (Operation | Block): The AST node currently being checked.
+        ctx (ValidationContext): Validation context, used to look up how the duration variable is
+            bound.
+
+    Yields:
+        One ``"qblox.arbitrary-wait-sweep"`` error [`Diagnostic`][qprogram.Diagnostic] when ``node`` is a
+        ``wait`` whose duration variable is bound to an arbitrary source. Nothing otherwise.
+    """
+    if not isinstance(node, Wait):
+        return
+    if not isinstance(node.duration, Variable):
+        return
+    if ctx.sweep_kind_of(node.duration) == "arbitrary":
+        yield Diagnostic(
+            severity="error",
+            code="qblox.arbitrary-wait-sweep",
+            message=(
+                f"Variable {node.duration.id!r} is swept with arbitrary "
+                f"values and used at Wait.duration, which qblox does not "
+                f"support (the wait instruction needs a linear step). Use "
+                f"a linear sweep source (Range / Linspace) instead, or a constant duration."
+            ),
+            node=node,
+        )
+
+
+def _drag_sigma_in_loop_is_host_only(
+    node: Operation | Block,
+    ctx: ValidationContext,
+) -> Iterable[Diagnostic | DomainConstraint]:
+    """Restrict the binding loop of a swept ``IQDrag.sigma`` to host-side dispatch.
+
+    A qblox sequencer re-arms a real-time loop with a new amplitude or duration on its own, but it
+    cannot recompute a Drag envelope's ``sigma`` between iterations: the gaussian and its derivative
+    are sampled once, at upload. Sweeping ``sigma`` therefore means re-uploading the waveform per
+    iteration, which the enclosing loop can only do host-side, one qblox shot at a time. The
+    [`Play`][qprogram.operations.Play] itself stays real-time; what changes is how the loop around it
+    iterates.
+
+    The constraint targets the loop returned by [`binding_loop_of`][qprogram.ValidationContext.binding_loop_of],
+    not the ``Play``, because that is the node whose iteration mechanism is at stake. The classifier
+    subtracts ``"rt"`` from the loop's support and dispatches the ``Play`` as one real-time shot per
+    host-side iteration. A ``sigma`` that no loop binds is a constant at upload time and is left
+    alone.
+
+    Args:
+        node (Operation | Block): The AST node currently being checked.
+        ctx (ValidationContext): Validation context, used to find the loop that binds ``sigma``.
+
+    Yields:
+        One [`DomainConstraint`][qprogram.DomainConstraint] excluding ``"rt"`` from the binding loop, when
+        ``node`` is a ``play`` of an [`IQDrag`][qprogram.waveforms.IQDrag] whose ``sigma`` is a
+        loop-bound variable. Nothing otherwise.
+    """
+    if not isinstance(node, Play) or not isinstance(node.waveform, IQDrag):
+        return
+    sigma = node.waveform.sigma
+    if not isinstance(sigma, Variable):
+        return
+    binding_loop = ctx.binding_loop_of(sigma)
+    if binding_loop is None:
+        return
+    yield DomainConstraint(
+        node=binding_loop,
+        exclude=frozenset({"rt"}),
+        reason=(
+            f"Variable {sigma.id!r} sweeps IQDrag.sigma in a contained Play, which qblox "
+            f"cannot real-time-update; the loop dispatches per shot host-side instead."
+        ),
+    )
+
+
+_BUS_OPS: frozenset[str] = frozenset(
+    {
+        "op.play",
+        "op.measure",
+        "op.wait",
+        "op.sync",
+        "op.set_frequency",
+        "op.set_phase",
+        "op.set_gain",
+        "op.reset_phase",
+        "op.set_offset",
+    },
+)
+"""Core operations a qblox sequencer executes.
+
+Each of them targets a bus, so its token belongs on this bus-level profile rather than on the
+platform slot: the validator routes a bus-touching operation to the slot its bus resolves to.
+"""
+
+_WAVEFORMS: frozenset[str] = frozenset(
+    {
+        "waveform.single",
+        "waveform.iq",
+        "waveform.alias",
+        "waveform.arbitrary",
+        "waveform.chained",
+        "waveform.flat_top",
+        "waveform.gaussian",
+        "waveform.gaussian_drag_correction",
+        "waveform.ramp",
+        "waveform.snz",
+        "waveform.square",
+        "waveform.iq_drag",
+        "waveform.iq_pair",
+    },
+)
+"""Waveform tokens the qblox sequencers render.
+
+Two levels, both bus-level because a waveform only reaches the hardware through a bus: the channel
+kind (``waveform.single`` and ``waveform.iq``, since qblox drives both single-channel and IQ buses),
+``waveform.alias`` for a name a [`WaveformLibrary`][qprogram.WaveformLibrary] resolves later, and one per-class
+token for each envelope the sequencers can sample.
+"""
+
+_FIELDS: frozenset[str] = frozenset(
+    {
+        "measure.fields.iq",
+        "measure.fields.raw",
+        "measure.fields.state",
+    },
+)
+"""Measurement fields a qblox readout produces.
+
+All three core members of [`MeasurementField`][qprogram.MeasurementField]: the integrated IQ point, the raw ADC
+trace, and the thresholded state. [`Measure`][qprogram.operations.Measure] and
+[`acquire`][qprogram_qblox.QbloxNamespace.acquire] attach a ``measure.fields.<name>`` token per
+requested field and both target a bus, which is why the tokens are bus-level.
+"""
+
+_VENDOR: frozenset[str] = frozenset(
+    {
+        "vendor.qblox.acquire",
+        "vendor.qblox.set_markers",
+        "vendor.qblox.set_trigger",
+        "vendor.qblox.wait_trigger",
+        "vendor.qblox.set_acquisition_threshold",
+        "vendor.qblox.set_acquisition_rotation",
+    },
+)
+"""The ``vendor.qblox.*`` operation tokens.
+
+Every operation this package ships carries a ``bus``, so all six route to the bus slot. A bus-less
+vendor operation would need its token on the platform slot instead.
+"""
+
+
+QBLOX_DEFAULT_V1 = Profile(
+    name="qblox-default-v1",
+    version=(0, 1, 0),
+    extends=None,
+    capabilities=_BUS_OPS | _WAVEFORMS | _FIELDS | _VENDOR,
+    limits={"min_wait_duration_ns": 4},
+    predicates=(
+        _reject_arbitrary_sweep_at_wait_duration,
+        _drag_sigma_in_loop_is_host_only,
+    ),
+    vendor_versions={"qblox": (0, 1, 0)},
+)
+"""The default Qblox bus-level capability profile.
+
+Holds every token a qblox-driven bus accepts (`_BUS_OPS`, `_WAVEFORMS`, `_FIELDS`
+and `_VENDOR`), the ``min_wait_duration_ns`` floor of the wait instruction, and the two
+predicates above. It carries no ``block.*``, ``sweep.*`` or ``expr.*`` token: those route to the
+platform slot, which a qblox platform fills from ``qprogram-base-v1``.
+
+Reach it by name with
+``CompilerCapabilities.from_profile("qblox-default-v1", limit_overrides=...)``, or extend it with a
+profile of your own that declares ``extends="qblox-default-v1"`` and lists only what differs.
+"""
+
+
+def _register() -> None:
+    """Idempotently register [`QBLOX_DEFAULT_V1`][qprogram_qblox.QBLOX_DEFAULT_V1] on the global profile registry."""
+    register_profile(QBLOX_DEFAULT_V1)
+
+
+__all__ = ["QBLOX_DEFAULT_V1"]

qprogram_qblox-0.1.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.5
+Name: qprogram-qblox
+Version: 0.1.0
+Summary: Qblox vendor extensions for the QProgram pulse-level quantum programming DSL.
+Project-URL: Homepage, https://github.com/qilimanjaro-tech/qprogram-qblox
+Project-URL: Documentation, https://qilimanjaro-tech.github.io/qprogram-qblox/
+Project-URL: Source, https://github.com/qilimanjaro-tech/qprogram-qblox
+Project-URL: Issues, https://github.com/qilimanjaro-tech/qprogram-qblox/issues
+Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: dsl,pulse programming,qblox,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 Qblox
+
+[![Tests](https://github.com/qilimanjaro-tech/qprogram-qblox/actions/workflows/tests.yml/badge.svg)](https://github.com/qilimanjaro-tech/qprogram-qblox/actions/workflows/tests.yml)
+[![Code Quality](https://github.com/qilimanjaro-tech/qprogram-qblox/actions/workflows/code_quality.yml/badge.svg)](https://github.com/qilimanjaro-tech/qprogram-qblox/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)
+
+Qblox extensions for [QProgram](https://github.com/qilimanjaro-tech/qprogram), a Python DSL for
+pulse-level quantum experiments.
+
+The core DSL knows nothing about any instrument. This package teaches it about the Qblox cluster.
+It adds six operations that the portable language does not cover, a capability profile that says
+what QCM and QRM sequencers accept, and `.qp` serialization for everything it adds. Importing the
+package is the whole activation step.
+
+## Installation
+
+```bash
+pip install qprogram-qblox
+```
+
+The core `qprogram` package installs with it.
+
+## A first program
+
+Calibrate the acquisition rotation angle of a readout bus: sweep the angle, discriminate the
+qubit state at each point, and average the outcome.
+
+```python
+import math
+
+import qprogram as qp
+from qprogram.buses import BusSchema
+from qprogram.waveforms import IQDrag, IQPair, Square
+
+from qprogram_qblox import QProgram  # qprogram.QProgram with a typed .qblox namespace
+
+schema = BusSchema.transmon()
+q = schema.q
+
+program = QProgram(label="rotation_calibration", schema=schema)
+angle = program.variable("angle", units="rad")
+
+with program.average(shots=1000):
+    with program.sweep(angle).from_linspace(0.0, math.pi, 21):
+        program.qblox.set_acquisition_rotation(q[0].readout, angle)
+        program.play(q[0].drive, "pi_pulse")
+        program.sync()
+        m0 = program.qblox.acquire(q[0].readout, "weights", fields=(qp.MeasurementField.STATE,))
+
+# Bind calibrated waveforms at the very end; the program itself only names them.
+resolved = program.with_waveforms(
+    {
+        "pi_pulse": IQDrag(amplitude=0.5, duration=40, sigma=8, beta=0.1),
+        "weights": IQPair(Square(1.0, 2000), Square(1.0, 2000)),
+    }
+)
+
+result = qp.simulate(resolved)
+population = result.get(m0, field=qp.MeasurementField.STATE)
+print(population.dims, population.shape)  # ('angle',) (21,)
+```
+
+`qp.simulate` is the reference software executor that ships with the core package. It runs the
+qblox operations generically: `qblox.acquire` produces measurement records, the rest have no
+effect on the simulated outcome. A Qblox platform is a drop-in for the same call and lowers each
+operation onto real sequencers.
+
+## What you get
+
+- **Six operations under `program.qblox`.** `acquire` reads a bus without playing a readout
+  pulse. `set_markers` and `set_trigger` drive the digital outputs, `wait_trigger` waits on a
+  digital input. `set_acquisition_threshold` and `set_acquisition_rotation` configure
+  thresholded acquisition, and take effect off the sequencer as slow-control parameter writes
+  at execution time.
+- **Typed or dynamic access.** `qprogram_qblox.QProgram` has `.qblox` typed for autocomplete,
+  `QbloxMixin` composes with other vendor mixins, and the plain `qprogram.QProgram` gets the
+  same namespace at runtime once this package is imported.
+- **A capability profile.** `QBLOX_DEFAULT_V1` declares the operations, waveforms, measurement
+  fields, and limits of a qblox-driven bus, plus the two constraints the hardware imposes: an
+  arbitrary-valued sweep cannot drive a wait duration, and sweeping an `IQDrag` sigma forces its
+  loop to iterate host-side.
+- **Round-tripping `.qp` files.** Every operation serializes as `qblox.<name> <args>` and reloads
+  to a structurally equal program. Files carry `require qblox 0.1`, which the parser checks
+  against the installed version.
+- **Auto-activation on load.** `qprogram.load("file.qp")` imports this package on demand when the
+  file requires the `qblox` vendor, so a reader never has to know which extensions a file uses.
+
+## Documentation
+
+Full documentation, including the operation reference, the capability profile, and the generated
+API reference, lives at <https://qilimanjaro-tech.github.io/qprogram-qblox/>.
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone https://github.com/qilimanjaro-tech/qprogram-qblox
+cd qprogram-qblox
+
+uv sync --group dev                  # create .venv and install the package plus dev tools
+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_qblox-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+qprogram_qblox/__init__.py,sha256=g0LFTyI9OhT42BTPMhRy5GP8Fkfa_Me6vCFv3qveFgw,6532
+qprogram_qblox/mixin.py,sha256=UHVrXkpXpu5yV0ihW1wDW9eJXLh9b_xSHVIGLahUsuM,2975
+qprogram_qblox/namespace.py,sha256=U7jevfYu2LmEaQV2mhbXjAd_s8-fiGCYUZi0JbCNtsg,8515
+qprogram_qblox/operations.py,sha256=DtWXkJ46WpKZp6eroxThUlkEbRftPopUOalMlKHQrkE,10424
+qprogram_qblox/profiles.py,sha256=cfLjnKB-AeucFA-AFdrO72qckjpz83oJeHCcHwWNTGs,11160
+qprogram_qblox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qprogram_qblox-0.1.0.dist-info/METADATA,sha256=IjJ2H-G2nGnPlg-HVAR8Xt39e4in5Aj2tFFxGOXEL5o,6443
+qprogram_qblox-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+qprogram_qblox-0.1.0.dist-info/entry_points.txt,sha256=9-k7fH4cck1lXJ9j8j-aebXlzGtHyz3pFovFsEZ3jWU,42
+qprogram_qblox-0.1.0.dist-info/licenses/LICENSE,sha256=SSd4NLHKeN_X9uu9A5TnY3vpro7w7I9ZduIIsjtIBlo,11354
+qprogram_qblox-0.1.0.dist-info/RECORD,,

qprogram_qblox-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_qblox-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[qprogram.vendors]
+qblox = qprogram_qblox

qprogram_qblox-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.