qpi-driver 0.0.6__tar.gz

qpi_driver-0.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Martin Ahindura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qpi_driver-0.0.6/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: qpi-driver
+Version: 0.0.6
+Summary: Quantum Processing Interface (QPI) Hardware Driver
+Author-email: Martin Ahindura <team.sopherapps@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/sopherapps/qpi
+Project-URL: Repository, https://github.com/sopherapps/qpi
+Project-URL: Documentation, https://github.com/sopherapps/qpi
+Project-URL: Issues, https://github.com/sopherapps/qpi/issues
+Project-URL: Changelog, https://github.com/sopherapps/qpi/blob/main/CHANGELOG.md
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: pynng>=0.8.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: qiskit>=1.0.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: qiskit_qasm3_import
+Provides-Extra: cli
+Requires-Dist: typer>=0.9.0; extra == "cli"
+Provides-Extra: aer
+Requires-Dist: qiskit-aer>=0.14.0; extra == "aer"
+Provides-Extra: quantify
+Requires-Dist: quantify-scheduler; extra == "quantify"
+Requires-Dist: qblox-instruments; extra == "quantify"
+Provides-Extra: qblox
+Requires-Dist: qblox-scheduler>=1.0.0b1; extra == "qblox"
+Requires-Dist: qblox-instruments; extra == "qblox"
+Dynamic: license-file

qpi_driver-0.0.6/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qpi-driver"
+version = "0.0.6"
+description = "Quantum Processing Interface (QPI) Hardware Driver"
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+license = { text = "MIT" }
+authors = [
+    { name = "Martin Ahindura", email = "team.sopherapps@gmail.com" },
+]
+dependencies = [
+    "numpy>=2.0.0",
+    "xarray>=2024.1.0",
+    "pynng>=0.8.0",
+    "requests>=2.31.0",
+    "qiskit>=1.0.0",
+    "scipy>=1.10.0",
+    "pyyaml>=6.0",
+    "qiskit_qasm3_import"
+]
+
+[project.optional-dependencies]
+cli = ["typer>=0.9.0"]
+aer = ["qiskit-aer>=0.14.0"]
+quantify = [
+    "quantify-scheduler",
+    "qblox-instruments"
+]
+qblox = [
+    "qblox-scheduler>=1.0.0b1",
+    "qblox-instruments"
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.3.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/sopherapps/qpi"
+Repository = "https://github.com/sopherapps/qpi"
+Documentation = "https://github.com/sopherapps/qpi"
+Issues = "https://github.com/sopherapps/qpi/issues"
+Changelog = "https://github.com/sopherapps/qpi/blob/main/CHANGELOG.md"
+
+[project.scripts]
+qpi-driver = "qpi_driver.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["qpi_driver*"]
+
+[tool.uv]
+override-dependencies = [
+    "pyqt5-qt5>=5.15.10",
+    "pyqt5>=5.15.10",
+    "qcodes<0.57"
+]

qpi_driver-0.0.6/qpi_driver/__init__.py

@@ -0,0 +1,25 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("qpi-driver")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.6"
+
+from qpi_driver.driver import run_driver
+from qpi_driver.executors.base import Executor
+from qpi_driver.executors.mock import MockExecutor
+from qpi_driver.executors.presto import PrestoExecutor
+from qpi_driver.executors.qblox import QbloxExecutor
+from qpi_driver.executors.qiskit_aer import QiskitAerExecutor
+from qpi_driver.executors.quantify import QuantifyExecutor
+
+__all__ = [
+    "__version__",
+    "run_driver",
+    "Executor",
+    "MockExecutor",
+    "QiskitAerExecutor",
+    "QuantifyExecutor",
+    "QbloxExecutor",
+    "PrestoExecutor",
+]

qpi_driver-0.0.6/qpi_driver/cli.py

@@ -0,0 +1,138 @@
+import importlib.metadata
+from pathlib import Path
+from typing import Annotated
+
+from qpi_driver.compat import typer
+from qpi_driver.driver import run_driver
+
+app = None
+if typer.IS_TYPER_INSTALLED:
+    app = typer.Typer(help="Quantum Processing Interface (QPI) Hardware Driver CLI")
+
+    @app.command()
+    def start(
+        qpi_addr: Annotated[
+            str,
+            typer.Option(
+                "--qpi-addr",
+                "-a",
+                envvar="QPI_ADDR",
+                help="Full URL of the QPI orchestrator (e.g. http://localhost:8090 or https://qpi.example.com)",
+            ),
+        ] = "http://127.0.0.1:8090",
+        token: Annotated[
+            str,
+            typer.Option(
+                "--token",
+                "-t",
+                envvar="QPI_ACCESS_TOKEN",
+                help="QPU access token matching a qpus.access_token record",
+            ),
+        ] = "",
+        name: Annotated[
+            str,
+            typer.Option(
+                "--name",
+                "-n",
+                envvar="QPU_NAME",
+                help="Human-readable name for this QPU",
+            ),
+        ] = "qpu_sim_01",
+        executor: Annotated[
+            str,
+            typer.Option(
+                "--executor",
+                "-e",
+                envvar="DRIVER_BACKEND",
+                help="Which executor backend to use (mock, qiskit_aer, quantify, qblox, presto)",
+            ),
+        ] = "mock",
+        data_dir: Annotated[
+            Path,
+            typer.Option(
+                "--data-dir",
+                "-d",
+                envvar="QPI_DATA_DIR",
+                help="Directory where intermediate pickled datasets are written",
+                writable=True,
+                readable=True,
+                dir_okay=True,
+                file_okay=False,
+                resolve_path=True,
+            ),
+        ] = Path("./bin/data"),
+        is_dummy: Annotated[
+            bool,
+            typer.Option(
+                "--is-dummy",
+                help="Whether to run the executor in dummy/simulation mode",
+            ),
+        ] = False,
+        quantify_hardware_config: Annotated[
+            Path,
+            typer.Option(
+                envvar="QPI_QUANTIFY_HARDWARE_CONFIG",
+                help="Path to the quantify hardware-layer configuration file containing specifications about the RF control instruments",
+                readable=True,
+                dir_okay=False,
+                file_okay=True,
+                resolve_path=True,
+            ),
+        ] = Path("./quantify.hardware.json"),
+        quantify_device_config: Annotated[
+            Path,
+            typer.Option(
+                envvar="QPI_QUANTIFY_DEVICE_CONFIG",
+                help="Path to the quantify device-layer configuration file containing specifications about the chip",
+                readable=True,
+                dir_okay=False,
+                file_okay=True,
+                resolve_path=True,
+            ),
+        ] = Path("./quantify.device.yml"),
+        job_timeout: Annotated[
+            int,
+            typer.Option(
+                envvar="QPI_JOB_TIMEOUT",
+                help="The number of seconds to wait for a job to complete.",
+            ),
+        ] = 10,
+    ):
+        """
+        Start the QPI driver.
+        """
+        if not token:
+            typer.echo(
+                "Error: access token is required. "
+                "Set it via --token / -t or the QPI_ACCESS_TOKEN environment variable.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+
+        run_driver(
+            qpi_addr=qpi_addr,
+            token=token,
+            name=name,
+            executor=executor,
+            data_dir=data_dir,
+            is_dummy=is_dummy,
+            quantify_hardware_config=quantify_hardware_config,
+            quantify_device_config=quantify_device_config,
+            job_timeout=job_timeout,
+        )
+
+    @app.command()
+    def version():
+        """
+        Show the version of the QPI driver.
+        """
+
+        try:
+            ver = importlib.metadata.version("qpi-driver")
+        except importlib.metadata.PackageNotFoundError:
+            ver = "0.0.6"
+
+        typer.echo(ver)
+
+    if __name__ == "__main__":
+        app()

qpi_driver-0.0.6/qpi_driver/compat/qblox.py

@@ -0,0 +1,120 @@
+"""Module containing compatibility imports for qblox-scheduler-related libraries"""
+
+import logging
+from enum import Enum
+from typing import Any, TypeAlias
+
+from qpi_driver.compat.shared import BasicCompatClass
+
+try:
+    from pydantic import BaseModel, ImportString, field_validator
+    from qblox_instruments import Cluster, ClusterType, InstrumentType  # noqa: F401
+    from qblox_scheduler import HardwareAgent, Schedule  # noqa: F401
+    from qblox_scheduler.device_under_test.quantum_device import (
+        DeviceElement,
+        Edge,
+        QuantumDevice,  # noqa: F401
+    )
+    from qblox_scheduler.device_under_test.transmon_element import (
+        BasicTransmonElement,  # noqa: F401
+    )
+    from qblox_scheduler.operations import (
+        CNOT,
+        CZ,
+        H,
+        IdlePulse,
+        Measure,
+        Operation,
+        Reset,
+        Rxy,
+        Rz,
+        S,
+        SDagger,
+        T,
+        TDagger,
+        X,
+        Y,
+        Z,
+    )
+    from qblox_scheduler.qblox.hardware_agent import (
+        QbloxHardwareCompilationConfig,  # noqa: F401
+    )
+    from qblox_scheduler.schedules import Schedulable
+    from qcodes.instrument import InstrumentModule  # noqa: F401
+    from qcodes.instrument.base import Instrument  # noqa: F401
+    from qcodes.parameters import ParameterBase  # noqa: F401
+
+    IS_QBLOX_SCHEDULER_INSTALLED: bool = True
+
+except ImportError as exp:
+    logging.debug(f"failed importing from qblox.compat {exp}")
+    IS_QBLOX_SCHEDULER_INSTALLED: bool = False
+
+    HardwareAgent: TypeAlias = Any
+    QbloxHardwareCompilationConfig: TypeAlias = Any
+    QuantumDevice: TypeAlias = Any
+    BasicTransmonElement: TypeAlias = Any
+    Cluster: TypeAlias = Any
+    ImportString: TypeAlias = Any
+    Schedulable: TypeAlias = Any
+
+    class DeviceElement(BasicCompatClass): ...
+
+    class Edge(BasicCompatClass): ...
+
+    class BaseModel(BasicCompatClass): ...
+
+    class CNOT(BasicCompatClass): ...
+
+    class CZ(BasicCompatClass): ...
+
+    class H(BasicCompatClass): ...
+
+    class Measure(BasicCompatClass): ...
+
+    class Reset(BasicCompatClass): ...
+
+    class Rxy(BasicCompatClass): ...
+
+    class Rz(BasicCompatClass): ...
+
+    class X(BasicCompatClass): ...
+
+    class Y(BasicCompatClass): ...
+
+    class Z(BasicCompatClass): ...
+
+    class S(BasicCompatClass): ...
+
+    class T(BasicCompatClass): ...
+
+    class SDagger(BasicCompatClass): ...
+
+    class TDagger(BasicCompatClass): ...
+
+    class IdlePulse(BasicCompatClass): ...
+
+    class InstrumentModule(BasicCompatClass): ...
+
+    class ParameterBase(BasicCompatClass): ...
+
+    class InstrumentType(Enum): ...
+
+    class ClusterType(Enum): ...
+
+    class Operation(BasicCompatClass): ...
+
+    class Schedule(BasicCompatClass):
+        def add(self, *args, **kwargs):
+            pass
+
+    class Instrument(BasicCompatClass):
+        @classmethod
+        def close_all(cls):
+            pass
+
+    def field_validator(*args, **kwargs):
+        def decor(*args, **kwargs):
+            return args
+
+        return decor

qpi_driver-0.0.6/qpi_driver/compat/qiskit_aer.py

@@ -0,0 +1,12 @@
+"""Module containing compatibility helpers for Qiskit aer."""
+
+from qpi_driver.compat.shared import BasicCompatClass
+
+try:
+    from qiskit_aer import AerSimulator
+
+    IS_AER_INSTALLED: bool = True
+except ImportError:
+    IS_AER_INSTALLED: bool = False
+
+    class AerSimulator(BasicCompatClass): ...

qpi_driver-0.0.6/qpi_driver/compat/quantify.py

@@ -0,0 +1,131 @@
+"""Module containing compatibility imports for quantify-related libraries"""
+
+import logging
+from enum import Enum
+from typing import Any, TypeAlias
+
+from qpi_driver.compat.shared import BasicCompatClass
+
+try:
+    from pydantic import BaseModel, ImportString, field_validator
+    from qblox_instruments import Cluster, ClusterType, InstrumentType
+    from qcodes.instrument import InstrumentModule
+    from qcodes.instrument.base import Instrument
+    from qcodes.parameters import ParameterBase
+    from quantify_core.data.handling import set_datadir
+    from quantify_scheduler import Operation, Schedule
+    from quantify_scheduler.backends.graph_compilation import SerialCompiler
+    from quantify_scheduler.backends.qblox_backend import (
+        QbloxHardwareCompilationConfig,
+    )
+    from quantify_scheduler.backends.types.qblox import ClusterDescription
+    from quantify_scheduler.device_under_test.quantum_device import (
+        DeviceElement,
+        Edge,
+        QuantumDevice,
+    )
+    from quantify_scheduler.device_under_test.transmon_element import (
+        BasicTransmonElement,
+    )
+    from quantify_scheduler.instrument_coordinator import InstrumentCoordinator
+    from quantify_scheduler.operations.gate_library import (
+        CNOT,
+        CZ,
+        H,
+        Measure,
+        Reset,
+        Rxy,
+        Rz,
+        S,
+        SDagger,
+        T,
+        TDagger,
+        X,
+        Y,
+        Z,
+    )
+    from quantify_scheduler.operations.pulse_library import IdlePulse
+    from quantify_scheduler.qblox import ClusterComponent
+    from quantify_scheduler.schedules import Schedulable
+
+    IS_QUANTIFY_INSTALLED: bool = True
+
+except ImportError as exp:
+    logging.debug(f"failed importing from quantify.compat {exp}")
+    IS_QUANTIFY_INSTALLED: bool = False
+
+    def set_datadir(*args, **kwargs):
+        pass
+
+    def field_validator(*args, **kwargs):
+        def decor(*args, **kwargs):
+            return args
+
+        return decor
+
+    QbloxHardwareCompilationConfig: TypeAlias = Any
+    ClusterComponent: TypeAlias = Any
+    InstrumentCoordinator: TypeAlias = Any
+    BasicTransmonElement: TypeAlias = Any
+    QuantumDevice: TypeAlias = Any
+    SerialCompiler: TypeAlias = Any
+    Cluster: TypeAlias = Any
+    ImportString: TypeAlias = Any
+    Schedulable: TypeAlias = Any
+
+    class DeviceElement(BasicCompatClass): ...
+
+    class Edge(BasicCompatClass): ...
+
+    class BaseModel(BasicCompatClass): ...
+
+    class CNOT(BasicCompatClass): ...
+
+    class CZ(BasicCompatClass): ...
+
+    class H(BasicCompatClass): ...
+
+    class Measure(BasicCompatClass): ...
+
+    class Reset(BasicCompatClass): ...
+
+    class Rxy(BasicCompatClass): ...
+
+    class Rz(BasicCompatClass): ...
+
+    class X(BasicCompatClass): ...
+
+    class Y(BasicCompatClass): ...
+
+    class Z(BasicCompatClass): ...
+
+    class S(BasicCompatClass): ...
+
+    class T(BasicCompatClass): ...
+
+    class SDagger(BasicCompatClass): ...
+
+    class TDagger(BasicCompatClass): ...
+
+    class IdlePulse(BasicCompatClass): ...
+
+    class InstrumentModule(BasicCompatClass): ...
+
+    class ParameterBase(BasicCompatClass): ...
+
+    class ClusterDescription(BasicCompatClass): ...
+
+    class InstrumentType(Enum): ...
+
+    class ClusterType(Enum): ...
+
+    class Operation(BasicCompatClass): ...
+
+    class Schedule(BasicCompatClass):
+        def add(self, *args, **kwargs):
+            pass
+
+    class Instrument(BasicCompatClass):
+        @classmethod
+        def close_all(cls):
+            pass

qpi_driver-0.0.6/qpi_driver/compat/shared.py

@@ -0,0 +1,6 @@
+"""Common compatibility utils"""
+
+
+class BasicCompatClass:
+    def __init__(self, *args, **kwargs):
+        pass

qpi_driver-0.0.6/qpi_driver/compat/typer.py

@@ -0,0 +1,19 @@
+"""Module containing compatibility imports for typer-related libraries"""
+
+from qpi_driver.compat.shared import BasicCompatClass
+
+try:
+    from typer import Exit, Option, Typer, echo
+
+    IS_TYPER_INSTALLED: bool = True
+except ImportError:
+    IS_TYPER_INSTALLED: bool = False
+
+    class Option(BasicCompatClass): ...
+
+    class Typer(BasicCompatClass): ...
+
+    class Exit(BasicCompatClass): ...
+
+    def echo(*args, **kwargs):
+        pass