openquantum-sdk-qrisp 0.5.0__tar.gz

openquantum_sdk_qrisp-0.5.0/MANIFEST.in

@@ -0,0 +1,9 @@
+# Unit tests ship in the sdist. The wheel does not install them.
+include README.md
+include pyproject.toml
+recursive-include qrisp_openquantum *.py
+recursive-include tests *.py
+global-exclude *.pyc
+global-exclude __pycache__
+prune .venv
+prune .pytest_cache

openquantum_sdk_qrisp-0.5.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: openquantum-sdk-qrisp
+Version: 0.5.0
+Summary: Qrisp Python SDK for Open Quantum
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: openquantum-sdk>=1.0.0
+Requires-Dist: openquantum-sdk-qiskit>=1.0.0
+Requires-Dist: qrisp>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+
+# Qrisp-Open Quantum Plugin
+
+> **Beta.** This plugin is in beta; its API and defaults may still change. Feedback is welcome in the [Quantum Rings community](https://www.quantumrings.com/community).
+
+A backend for the [Qrisp](https://www.qrisp.eu/) quantum programming framework
+that submits circuits to the [Open Quantum](https://www.openquantum.com)
+platform. Write high-level Qrisp programs and run them on real quantum hardware.
+
+## How it works
+
+Qrisp already depends on Qiskit and can convert any circuit to a Qiskit circuit
+(`QuantumCircuit.to_qiskit()`). This backend uses that bridge to reuse the Open
+Quantum Qiskit plugin:
+
+- `OpenQuantumService` handles authentication and backend discovery.
+- The capability-aware `OpenQuantumBackend` (a Qiskit `BackendV2`) validates each
+  circuit against the target device (gate set, coupling map, shot and qubit
+  limits).
+- `export_circuit_to_qasm` serialises to OpenQASM.
+
+Submission runs through the framework-agnostic `SchedulerClient` in the core
+SDK. No separate QASM serializer or auth code is reimplemented here.
+
+## Installation
+
+```bash
+# Plugin (and core SDK + Qiskit plugin)
+pip install openquantum-sdk-qrisp
+
+# or via extras:
+pip install "openquantum-sdk[qrisp]"
+```
+
+This pulls in `qrisp`, `openquantum-sdk`, and `openquantum-sdk-qiskit`.
+
+## Quick Start
+
+```python
+from qrisp import QuantumVariable, h, cx
+from qrisp_openquantum import OpenQuantumBackend
+
+oq = OpenQuantumBackend(
+    backend="ionq:aria-1",
+    shots=1024,
+    client_id="your_client_id",
+    client_secret="your_client_secret",
+)
+
+qv = QuantumVariable(2)
+h(qv[0])
+cx(qv[0], qv[1])
+
+print(qv.get_measurement(backend=oq, shots=1024))
+# {'00': 0.5, '11': 0.5}
+```
+
+`get_measurement` returns Qrisp's decoded outcomes as probabilities (its own
+normalization, applied for every backend). To get integer shot counts, run a
+raw `QuantumCircuit` directly:
+
+```python
+from qrisp import QuantumCircuit
+
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cx(0, 1)
+qc.measure([0, 1])
+
+counts = qc.run(backend=oq, shots=1024)
+# e.g. {'00': 518, '11': 506}
+```
+
+## Authentication
+
+Resolved in this order:
+
+1. **Pre-built service** — pass `service=OpenQuantumService(...)` for full control
+   (saved accounts, custom URLs, keyring).
+2. **Bearer token** — pass `token=` or set `OPENQUANTUM_TOKEN`.
+3. **Client credentials** — pass `client_id=` + `client_secret=` or set
+   `OPENQUANTUM_CLIENT_ID` + `OPENQUANTUM_CLIENT_SECRET`.
+
+| Parameter | Environment Variable | Description |
+|-----------|---------------------|-------------|
+| `token` | `OPENQUANTUM_TOKEN` | Bearer token |
+| `client_id` | `OPENQUANTUM_CLIENT_ID` | OAuth2 client ID |
+| `client_secret` | `OPENQUANTUM_CLIENT_SECRET` | OAuth2 client secret |
+| | `OPENQUANTUM_SDK_KEY` | Path to an SDK-key JSON file (`{client_id, client_secret}`) |
+| `organization_id` | `OPENQUANTUM_ORGANIZATION_ID` | Organization UUID (optional if single org) |
+| `scheduler_url` | `OPENQUANTUM_SCHEDULER_URL` | Scheduler API base, when the argument is omitted |
+| `management_url` | `OPENQUANTUM_MANAGEMENT_URL` | Management API base, when the argument is omitted |
+| `keycloak_base` | `OPENQUANTUM_KEYCLOAK_BASE` | Keycloak base, when the argument is omitted |
+| `realm` | `OPENQUANTUM_KEYCLOAK_REALM` | Keycloak realm, when the argument is omitted |
+
+`OpenQuantumService.from_env()` raises `AuthenticationError` when no credential resolves. Circuits are serialized with the public `export_circuit_to_qasm` helper from `openquantum_sdk_qiskit`. The older `OPENQUANTUM_*_BASE` URL names are not read here; those remain an MCP-only fallback.
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `backend` | required | Backend class ID or short_code (e.g. `"ionq:aria-1"`) |
+| `shots` | `1024` | Default shots when a Qrisp call omits them |
+| `job_subcategory_id` | `"oth:oth"` | Workload subcategory (set the most specific match) |
+| `execution_plan` | `"auto"` | `"auto"`, `"public"`, `"private"`, an enum, or a plan UUID. `"auto"` picks the cheapest plan |
+| `queue_priority` | `"auto"` | `"auto"`, `"standard"`, `"priority"`, `"instant"`, an enum, or a priority UUID. `"auto"` picks the cheapest priority |
+| `export_format` | `"qasm3"` | `"qasm2"` or `"qasm3"` |
+| `configuration_data` | `{}` | Backend-specific config passthrough (e.g. `{"engine": "amber_quantum_rings"}`) |
+| `reverse_bits` | `False` | Reverse returned bitstring order if a backend needs it |
+| `verbose` | `False` | Print submission progress and credit cost to stdout |
+| `job_timeout_seconds` | `86400` | Max wait for job completion (1 day) |
+
+## Backend-specific configuration
+
+Some backends require extra fields. The free Quantum Rings simulator
+(`qr:gpu-gb10`) requires an `engine`:
+
+```python
+oq = OpenQuantumBackend(
+    backend="qr:gpu-gb10",
+    shots=1024,
+    configuration_data={"engine": "amber_quantum_rings"},
+)
+```
+
+## Bit ordering
+
+Qrisp reads the leftmost character of a bitstring as the most-significant bit.
+The platform's counts are passed through unchanged by default. If a specific
+backend returns counts in the opposite order, construct the backend with
+`reverse_bits=True`.
+
+## License
+
+Apache License 2.0

openquantum_sdk_qrisp-0.5.0/README.md

@@ -0,0 +1,134 @@
+# Qrisp-Open Quantum Plugin
+
+> **Beta.** This plugin is in beta; its API and defaults may still change. Feedback is welcome in the [Quantum Rings community](https://www.quantumrings.com/community).
+
+A backend for the [Qrisp](https://www.qrisp.eu/) quantum programming framework
+that submits circuits to the [Open Quantum](https://www.openquantum.com)
+platform. Write high-level Qrisp programs and run them on real quantum hardware.
+
+## How it works
+
+Qrisp already depends on Qiskit and can convert any circuit to a Qiskit circuit
+(`QuantumCircuit.to_qiskit()`). This backend uses that bridge to reuse the Open
+Quantum Qiskit plugin:
+
+- `OpenQuantumService` handles authentication and backend discovery.
+- The capability-aware `OpenQuantumBackend` (a Qiskit `BackendV2`) validates each
+  circuit against the target device (gate set, coupling map, shot and qubit
+  limits).
+- `export_circuit_to_qasm` serialises to OpenQASM.
+
+Submission runs through the framework-agnostic `SchedulerClient` in the core
+SDK. No separate QASM serializer or auth code is reimplemented here.
+
+## Installation
+
+```bash
+# Plugin (and core SDK + Qiskit plugin)
+pip install openquantum-sdk-qrisp
+
+# or via extras:
+pip install "openquantum-sdk[qrisp]"
+```
+
+This pulls in `qrisp`, `openquantum-sdk`, and `openquantum-sdk-qiskit`.
+
+## Quick Start
+
+```python
+from qrisp import QuantumVariable, h, cx
+from qrisp_openquantum import OpenQuantumBackend
+
+oq = OpenQuantumBackend(
+    backend="ionq:aria-1",
+    shots=1024,
+    client_id="your_client_id",
+    client_secret="your_client_secret",
+)
+
+qv = QuantumVariable(2)
+h(qv[0])
+cx(qv[0], qv[1])
+
+print(qv.get_measurement(backend=oq, shots=1024))
+# {'00': 0.5, '11': 0.5}
+```
+
+`get_measurement` returns Qrisp's decoded outcomes as probabilities (its own
+normalization, applied for every backend). To get integer shot counts, run a
+raw `QuantumCircuit` directly:
+
+```python
+from qrisp import QuantumCircuit
+
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cx(0, 1)
+qc.measure([0, 1])
+
+counts = qc.run(backend=oq, shots=1024)
+# e.g. {'00': 518, '11': 506}
+```
+
+## Authentication
+
+Resolved in this order:
+
+1. **Pre-built service** — pass `service=OpenQuantumService(...)` for full control
+   (saved accounts, custom URLs, keyring).
+2. **Bearer token** — pass `token=` or set `OPENQUANTUM_TOKEN`.
+3. **Client credentials** — pass `client_id=` + `client_secret=` or set
+   `OPENQUANTUM_CLIENT_ID` + `OPENQUANTUM_CLIENT_SECRET`.
+
+| Parameter | Environment Variable | Description |
+|-----------|---------------------|-------------|
+| `token` | `OPENQUANTUM_TOKEN` | Bearer token |
+| `client_id` | `OPENQUANTUM_CLIENT_ID` | OAuth2 client ID |
+| `client_secret` | `OPENQUANTUM_CLIENT_SECRET` | OAuth2 client secret |
+| | `OPENQUANTUM_SDK_KEY` | Path to an SDK-key JSON file (`{client_id, client_secret}`) |
+| `organization_id` | `OPENQUANTUM_ORGANIZATION_ID` | Organization UUID (optional if single org) |
+| `scheduler_url` | `OPENQUANTUM_SCHEDULER_URL` | Scheduler API base, when the argument is omitted |
+| `management_url` | `OPENQUANTUM_MANAGEMENT_URL` | Management API base, when the argument is omitted |
+| `keycloak_base` | `OPENQUANTUM_KEYCLOAK_BASE` | Keycloak base, when the argument is omitted |
+| `realm` | `OPENQUANTUM_KEYCLOAK_REALM` | Keycloak realm, when the argument is omitted |
+
+`OpenQuantumService.from_env()` raises `AuthenticationError` when no credential resolves. Circuits are serialized with the public `export_circuit_to_qasm` helper from `openquantum_sdk_qiskit`. The older `OPENQUANTUM_*_BASE` URL names are not read here; those remain an MCP-only fallback.
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `backend` | required | Backend class ID or short_code (e.g. `"ionq:aria-1"`) |
+| `shots` | `1024` | Default shots when a Qrisp call omits them |
+| `job_subcategory_id` | `"oth:oth"` | Workload subcategory (set the most specific match) |
+| `execution_plan` | `"auto"` | `"auto"`, `"public"`, `"private"`, an enum, or a plan UUID. `"auto"` picks the cheapest plan |
+| `queue_priority` | `"auto"` | `"auto"`, `"standard"`, `"priority"`, `"instant"`, an enum, or a priority UUID. `"auto"` picks the cheapest priority |
+| `export_format` | `"qasm3"` | `"qasm2"` or `"qasm3"` |
+| `configuration_data` | `{}` | Backend-specific config passthrough (e.g. `{"engine": "amber_quantum_rings"}`) |
+| `reverse_bits` | `False` | Reverse returned bitstring order if a backend needs it |
+| `verbose` | `False` | Print submission progress and credit cost to stdout |
+| `job_timeout_seconds` | `86400` | Max wait for job completion (1 day) |
+
+## Backend-specific configuration
+
+Some backends require extra fields. The free Quantum Rings simulator
+(`qr:gpu-gb10`) requires an `engine`:
+
+```python
+oq = OpenQuantumBackend(
+    backend="qr:gpu-gb10",
+    shots=1024,
+    configuration_data={"engine": "amber_quantum_rings"},
+)
+```
+
+## Bit ordering
+
+Qrisp reads the leftmost character of a bitstring as the most-significant bit.
+The platform's counts are passed through unchanged by default. If a specific
+backend returns counts in the opposite order, construct the backend with
+`reverse_bits=True`.
+
+## License
+
+Apache License 2.0

openquantum_sdk_qrisp-0.5.0/openquantum_sdk_qrisp.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: openquantum-sdk-qrisp
+Version: 0.5.0
+Summary: Qrisp Python SDK for Open Quantum
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: openquantum-sdk>=1.0.0
+Requires-Dist: openquantum-sdk-qiskit>=1.0.0
+Requires-Dist: qrisp>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+
+# Qrisp-Open Quantum Plugin
+
+> **Beta.** This plugin is in beta; its API and defaults may still change. Feedback is welcome in the [Quantum Rings community](https://www.quantumrings.com/community).
+
+A backend for the [Qrisp](https://www.qrisp.eu/) quantum programming framework
+that submits circuits to the [Open Quantum](https://www.openquantum.com)
+platform. Write high-level Qrisp programs and run them on real quantum hardware.
+
+## How it works
+
+Qrisp already depends on Qiskit and can convert any circuit to a Qiskit circuit
+(`QuantumCircuit.to_qiskit()`). This backend uses that bridge to reuse the Open
+Quantum Qiskit plugin:
+
+- `OpenQuantumService` handles authentication and backend discovery.
+- The capability-aware `OpenQuantumBackend` (a Qiskit `BackendV2`) validates each
+  circuit against the target device (gate set, coupling map, shot and qubit
+  limits).
+- `export_circuit_to_qasm` serialises to OpenQASM.
+
+Submission runs through the framework-agnostic `SchedulerClient` in the core
+SDK. No separate QASM serializer or auth code is reimplemented here.
+
+## Installation
+
+```bash
+# Plugin (and core SDK + Qiskit plugin)
+pip install openquantum-sdk-qrisp
+
+# or via extras:
+pip install "openquantum-sdk[qrisp]"
+```
+
+This pulls in `qrisp`, `openquantum-sdk`, and `openquantum-sdk-qiskit`.
+
+## Quick Start
+
+```python
+from qrisp import QuantumVariable, h, cx
+from qrisp_openquantum import OpenQuantumBackend
+
+oq = OpenQuantumBackend(
+    backend="ionq:aria-1",
+    shots=1024,
+    client_id="your_client_id",
+    client_secret="your_client_secret",
+)
+
+qv = QuantumVariable(2)
+h(qv[0])
+cx(qv[0], qv[1])
+
+print(qv.get_measurement(backend=oq, shots=1024))
+# {'00': 0.5, '11': 0.5}
+```
+
+`get_measurement` returns Qrisp's decoded outcomes as probabilities (its own
+normalization, applied for every backend). To get integer shot counts, run a
+raw `QuantumCircuit` directly:
+
+```python
+from qrisp import QuantumCircuit
+
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cx(0, 1)
+qc.measure([0, 1])
+
+counts = qc.run(backend=oq, shots=1024)
+# e.g. {'00': 518, '11': 506}
+```
+
+## Authentication
+
+Resolved in this order:
+
+1. **Pre-built service** — pass `service=OpenQuantumService(...)` for full control
+   (saved accounts, custom URLs, keyring).
+2. **Bearer token** — pass `token=` or set `OPENQUANTUM_TOKEN`.
+3. **Client credentials** — pass `client_id=` + `client_secret=` or set
+   `OPENQUANTUM_CLIENT_ID` + `OPENQUANTUM_CLIENT_SECRET`.
+
+| Parameter | Environment Variable | Description |
+|-----------|---------------------|-------------|
+| `token` | `OPENQUANTUM_TOKEN` | Bearer token |
+| `client_id` | `OPENQUANTUM_CLIENT_ID` | OAuth2 client ID |
+| `client_secret` | `OPENQUANTUM_CLIENT_SECRET` | OAuth2 client secret |
+| | `OPENQUANTUM_SDK_KEY` | Path to an SDK-key JSON file (`{client_id, client_secret}`) |
+| `organization_id` | `OPENQUANTUM_ORGANIZATION_ID` | Organization UUID (optional if single org) |
+| `scheduler_url` | `OPENQUANTUM_SCHEDULER_URL` | Scheduler API base, when the argument is omitted |
+| `management_url` | `OPENQUANTUM_MANAGEMENT_URL` | Management API base, when the argument is omitted |
+| `keycloak_base` | `OPENQUANTUM_KEYCLOAK_BASE` | Keycloak base, when the argument is omitted |
+| `realm` | `OPENQUANTUM_KEYCLOAK_REALM` | Keycloak realm, when the argument is omitted |
+
+`OpenQuantumService.from_env()` raises `AuthenticationError` when no credential resolves. Circuits are serialized with the public `export_circuit_to_qasm` helper from `openquantum_sdk_qiskit`. The older `OPENQUANTUM_*_BASE` URL names are not read here; those remain an MCP-only fallback.
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `backend` | required | Backend class ID or short_code (e.g. `"ionq:aria-1"`) |
+| `shots` | `1024` | Default shots when a Qrisp call omits them |
+| `job_subcategory_id` | `"oth:oth"` | Workload subcategory (set the most specific match) |
+| `execution_plan` | `"auto"` | `"auto"`, `"public"`, `"private"`, an enum, or a plan UUID. `"auto"` picks the cheapest plan |
+| `queue_priority` | `"auto"` | `"auto"`, `"standard"`, `"priority"`, `"instant"`, an enum, or a priority UUID. `"auto"` picks the cheapest priority |
+| `export_format` | `"qasm3"` | `"qasm2"` or `"qasm3"` |
+| `configuration_data` | `{}` | Backend-specific config passthrough (e.g. `{"engine": "amber_quantum_rings"}`) |
+| `reverse_bits` | `False` | Reverse returned bitstring order if a backend needs it |
+| `verbose` | `False` | Print submission progress and credit cost to stdout |
+| `job_timeout_seconds` | `86400` | Max wait for job completion (1 day) |
+
+## Backend-specific configuration
+
+Some backends require extra fields. The free Quantum Rings simulator
+(`qr:gpu-gb10`) requires an `engine`:
+
+```python
+oq = OpenQuantumBackend(
+    backend="qr:gpu-gb10",
+    shots=1024,
+    configuration_data={"engine": "amber_quantum_rings"},
+)
+```
+
+## Bit ordering
+
+Qrisp reads the leftmost character of a bitstring as the most-significant bit.
+The platform's counts are passed through unchanged by default. If a specific
+backend returns counts in the opposite order, construct the backend with
+`reverse_bits=True`.
+
+## License
+
+Apache License 2.0

openquantum_sdk_qrisp-0.5.0/openquantum_sdk_qrisp.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+MANIFEST.in
+README.md
+pyproject.toml
+openquantum_sdk_qrisp.egg-info/PKG-INFO
+openquantum_sdk_qrisp.egg-info/SOURCES.txt
+openquantum_sdk_qrisp.egg-info/dependency_links.txt
+openquantum_sdk_qrisp.egg-info/requires.txt
+openquantum_sdk_qrisp.egg-info/top_level.txt
+qrisp_openquantum/__init__.py
+qrisp_openquantum/backend.py
+qrisp_openquantum/job.py
+tests/__init__.py
+tests/conftest.py
+tests/test_backend.py
+tests/test_integration.py

openquantum_sdk_qrisp-0.5.0/openquantum_sdk_qrisp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openquantum_sdk_qrisp-0.5.0/openquantum_sdk_qrisp.egg-info/requires.txt

@@ -0,0 +1,8 @@
+openquantum-sdk>=1.0.0
+openquantum-sdk-qiskit>=1.0.0
+qrisp>=0.9
+
+[dev]
+pytest>=7.0
+pytest-cov
+pytest-mock>=3.10

openquantum_sdk_qrisp-0.5.0/openquantum_sdk_qrisp.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+qrisp_openquantum

openquantum_sdk_qrisp-0.5.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openquantum-sdk-qrisp"
+version = "0.5.0"
+description = "Qrisp Python SDK for Open Quantum"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.11"
+dependencies = [
+  "openquantum-sdk>=1.0.0",
+  "openquantum-sdk-qiskit>=1.0.0",
+  "qrisp>=0.9",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+]
+
+# Qrisp has no entry-point/plugin discovery mechanism. Backends are plain
+# objects passed at call time, e.g. ``qv.get_measurement(backend=...)``. The
+# user imports OpenQuantumBackend and hands it to Qrisp directly.
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "pytest-mock>=3.10",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "../.."]

openquantum_sdk_qrisp-0.5.0/qrisp_openquantum/__init__.py

@@ -0,0 +1,7 @@
+"""Qrisp backend for the Open Quantum quantum computing platform."""
+
+from qrisp_openquantum.backend import OpenQuantumBackend
+from qrisp_openquantum.job import OpenQuantumJob
+
+__version__ = "0.5.0"
+__all__ = ["OpenQuantumBackend", "OpenQuantumJob"]

openquantum_sdk_qrisp-0.5.0/qrisp_openquantum/backend.py

@@ -0,0 +1,310 @@
+"""Open Quantum backend for the Qrisp quantum programming framework.
+
+Qrisp circuits are converted to Qiskit circuits via ``QuantumCircuit.to_qiskit()``
+(Qrisp already depends on Qiskit), so this backend reuses the Open Quantum Qiskit
+plugin for the Qiskit-specific work:
+
+* ``OpenQuantumService`` for authentication and backend discovery,
+* the capability-aware ``OpenQuantumBackend`` (a Qiskit ``BackendV2``) for
+  circuit validation, and
+* ``export_circuit_to_qasm`` for serialisation.
+
+Submission itself goes through the framework-agnostic
+``openquantum_sdk.clients.SchedulerClient``. The result is a ``{bitstring: count}``
+dict per circuit, which is exactly the contract Qrisp's result layer expects.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from qiskit import QuantumCircuit as _QiskitCircuit
+from qrisp.interface import Backend as QrispBackend
+
+from openquantum_sdk.clients import JobSubmissionConfig
+from openquantum_sdk.exceptions import JobError
+from openquantum_sdk_qiskit import OpenQuantumService, export_circuit_to_qasm
+
+from qrisp_openquantum.job import OpenQuantumJob
+
+
+class OpenQuantumBackend(QrispBackend):
+    """Qrisp backend that executes circuits on the Open Quantum platform.
+
+    Pass an instance to any Qrisp execution call, e.g.
+    ``qv.get_measurement(backend=oq, shots=1024)`` or
+    ``qc.run(backend=oq, shots=1024)``.
+
+    Authentication mirrors the other Open Quantum plugins and is resolved in
+    this order:
+
+    1. A pre-built :class:`openquantum_sdk_qiskit.OpenQuantumService` passed as
+       ``service`` (full control over auth, URLs, saved accounts).
+    2. A bearer ``token`` (falls back to ``OPENQUANTUM_TOKEN``).
+    3. ``client_id`` + ``client_secret`` for the OAuth2 client-credentials flow
+       (fall back to ``OPENQUANTUM_CLIENT_ID`` / ``OPENQUANTUM_CLIENT_SECRET``).
+
+    Args:
+        backend: Backend class ID or short_code (e.g. ``"ionq:aria-1"``).
+        shots: Default shot count used when a Qrisp call does not specify one.
+        service: Pre-built ``OpenQuantumService`` instance.
+        token: Bearer token for the API. Falls back to ``OPENQUANTUM_TOKEN``.
+        client_id: OAuth2 client ID. Falls back to ``OPENQUANTUM_CLIENT_ID``.
+        client_secret: OAuth2 client secret. Falls back to
+            ``OPENQUANTUM_CLIENT_SECRET``.
+        organization_id: Organization UUID. Falls back to
+            ``OPENQUANTUM_ORGANIZATION_ID``.
+        scheduler_url: Scheduler API base URL.
+        management_url: Management API base URL.
+        keycloak_base: Keycloak base URL for OAuth2.
+        realm: Keycloak realm name.
+        job_subcategory_id: Job subcategory ID or short_code (default
+            ``"oth:oth"``).
+        execution_plan: ``"auto"`` (default), ``"public"``, or ``"private"``.
+        queue_priority: ``"auto"`` (default), ``"standard"``, ``"priority"``,
+            or ``"instant"``.
+        export_format: Circuit serialisation format, ``"qasm2"`` or ``"qasm3"``
+            (default).
+        configuration_data: Backend-specific configuration passthrough (e.g.
+            ``{"engine": "amber_quantum_rings"}`` for ``qr:gpu-gb10``). ``shots``
+            is injected automatically from the per-run shot count.
+        reverse_bits: Reverse the bit order of returned bitstrings. The default
+            (``False``) passes the platform's bit order straight through to
+            Qrisp, which reads the leftmost character as the most-significant
+            bit. Set ``True`` only if a backend's counts come back in the
+            opposite order.
+        name: Optional Qrisp backend name (defaults to ``"openquantum"``).
+        verbose: Print submission progress and the credit cost to stdout.
+            Defaults to ``False``, matching
+            ``JobSubmissionConfig`` and the other plugins. Set ``True``
+            for step-by-step progress in a notebook or script.
+        job_timeout_seconds: Maximum seconds to wait for a job to complete
+            (default ``86400``, one day).
+    """
+
+    def __init__(
+        self,
+        backend: str,
+        *,
+        shots: int = 1024,
+        service: Optional[Any] = None,
+        token: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        scheduler_url: Optional[str] = None,
+        management_url: Optional[str] = None,
+        keycloak_base: Optional[str] = None,
+        realm: Optional[str] = None,
+        job_subcategory_id: str = "oth:oth",
+        execution_plan: str = "auto",
+        queue_priority: str = "auto",
+        export_format: str = "qasm3",
+        configuration_data: Optional[Dict[str, Any]] = None,
+        reverse_bits: bool = False,
+        name: Optional[str] = None,
+        verbose: bool = False,
+        job_timeout_seconds: int = 86_400,
+    ) -> None:
+        if not backend:
+            raise ValueError(
+                "OpenQuantumBackend requires a backend "
+                "(e.g., backend='ionq:aria-1')."
+            )
+        fmt = (export_format or "qasm3").lower()
+        if fmt not in {"qasm2", "qasm3"}:
+            raise ValueError("export_format must be 'qasm2' or 'qasm3'")
+
+        super().__init__(name=name or "openquantum", options={"shots": int(shots)})
+
+        self._backend_class_id = backend
+        self._configuration_data = dict(configuration_data or {})
+        self._organization_id = organization_id or os.environ.get(
+            "OPENQUANTUM_ORGANIZATION_ID"
+        )
+        self._job_subcategory_id = job_subcategory_id
+        self._execution_plan = execution_plan
+        self._queue_priority = queue_priority
+        self._export_format = fmt
+        self._reverse_bits = reverse_bits
+        self._verbose = verbose
+        self._job_timeout_seconds = int(job_timeout_seconds)
+
+        self._service = service or OpenQuantumService.from_env(
+            token=token,
+            client_id=client_id,
+            client_secret=client_secret,
+            scheduler_url=scheduler_url,
+            management_url=management_url,
+            keycloak_base=keycloak_base,
+            realm=realm,
+        )
+        self._scheduler = self._service.scheduler
+        # A capability-aware Qiskit BackendV2 used purely for client-side
+        # validation (gate set, coupling map, shot/qubit limits). It fetches
+        # constraint_data from the platform at construction time.
+        self._oq_backend = self._service.return_backend(
+            backend, export_format=fmt
+        )
+
+    @classmethod
+    def _default_options(cls):
+        return {"shots": 1024}
+
+    @property
+    def backend_class_id(self) -> str:
+        """The Open Quantum backend class ID or short_code targeted by this backend."""
+        return self._backend_class_id
+
+    @property
+    def backend(self) -> str:
+        """Alias for :attr:`backend_class_id` (matches the other plugins)."""
+        return self._backend_class_id
+
+    def run_async(
+        self,
+        circuits,
+        shots: Union[int, List[int], None] = None,
+    ) -> OpenQuantumJob:
+        """Submit one or more Qrisp circuits and return a completed job.
+
+        Each circuit is converted to a Qiskit circuit, validated against the
+        backend's capabilities, serialised to QASM, and submitted to the
+        platform synchronously.
+
+        Args:
+            circuits: A single Qrisp ``QuantumCircuit`` or a sequence of them.
+            shots: Shot count. An ``int`` applies to every circuit; a
+                ``list[int]`` sets per-circuit shots; ``None`` uses the
+                backend's default.
+
+        Returns:
+            An :class:`OpenQuantumJob` already in the ``DONE`` state.
+        """
+        batch = isinstance(circuits, (list, tuple))
+        circ_list = list(circuits) if batch else [circuits]
+
+        shots_list = self._resolve_shots(shots, len(circ_list))
+
+        counts_list: List[Dict[str, int]] = []
+        last_job_id: Optional[str] = None
+        for circ, circ_shots in zip(circ_list, shots_list):
+            counts, job_id = self._run_single(circ, circ_shots)
+            counts_list.append(counts)
+            last_job_id = job_id
+
+        return OpenQuantumJob(self, counts_list, job_id=last_job_id)
+
+    def _resolve_shots(
+        self, shots: Union[int, List[int], None], n_circuits: int
+    ) -> List[int]:
+        """Normalise ``shots`` into one positive int per circuit."""
+        if shots is None:
+            shots = self.options.get("shots")
+        if isinstance(shots, (list, tuple)):
+            if len(shots) != n_circuits:
+                raise ValueError(
+                    f"Received {len(shots)} shot values for {n_circuits} circuits."
+                )
+            return [int(s) for s in shots]
+        return [int(shots)] * n_circuits
+
+    @staticmethod
+    def _flatten_registers(qiskit_circuit):
+        """Rebuild a Qiskit circuit onto single quantum/classical registers.
+
+        Qrisp's ``to_qiskit()`` emits one register per qubit, but the platform
+        precompiler allows at most one qubit register. Composing onto a single
+        ``QuantumCircuit(n, m)`` remaps every qubit/clbit by position.
+        """
+        if len(qiskit_circuit.qregs) <= 1 and len(qiskit_circuit.cregs) <= 1:
+            return qiskit_circuit
+
+        flat = _QiskitCircuit(
+            qiskit_circuit.num_qubits,
+            qiskit_circuit.num_clbits,
+            name=qiskit_circuit.name,
+        )
+        flat.compose(
+            qiskit_circuit,
+            qubits=range(qiskit_circuit.num_qubits),
+            clbits=range(qiskit_circuit.num_clbits),
+            inplace=True,
+        )
+        return flat
+
+    def _transpile_for_backend(self, qiskit_circuit):
+        """Transpile a Qiskit circuit to the target device's native gate set.
+
+        Delegates to the Qiskit plugin backend's ``transpile`` wrapper (a thin
+        wrapper around ``qiskit.transpile`` bound to the device Target), which
+        carries the basis gates, coupling map, and qubit count. Transpilation
+        keeps each measurement writing to its original classical bit, so the
+        bitstring order returned by the platform (indexed by clbit) is
+        preserved; only the physical qubit placement changes.
+
+        Falls back to the untouched circuit when the backend does not expose a
+        transpile entry point (e.g. a minimal stub in tests).
+        """
+        transpile = getattr(self._oq_backend, "transpile", None)
+        if not callable(transpile):
+            return qiskit_circuit
+        # Use Qiskit's default optimization level, matching the Qiskit plugin.
+        # (An earlier optimization_level=1 pin worked around a VF2Layout crash;
+        # the real cause was a zero-qubit barrier in the device Target, now
+        # fixed in the Qiskit plugin, so the pin is no longer needed.)
+        return transpile(qiskit_circuit)
+
+    def _run_single(self, circ, shots: int):
+        """Serialise, submit, and collect counts for one circuit."""
+        qiskit_circuit = self._flatten_registers(circ.to_qiskit())
+
+        # Decompose to the device's native gate set before validation. Qrisp's
+        # high-level types emit composite gates (e.g. a 'QFT no swap_dg' from
+        # QuantumFloat arithmetic) that the capability-aware validator rejects
+        # on hardware-class backends. Transpiling against the Qiskit plugin's
+        # Target resolves basis translation, layout, and routing on the client,
+        # which is exactly where the platform expects that work to happen.
+        qiskit_circuit = self._transpile_for_backend(qiskit_circuit)
+
+        # Reuse the Qiskit plugin's capability-aware validation when available.
+        validate = getattr(self._oq_backend, "validate_circuit", None)
+        if callable(validate):
+            validate(qiskit_circuit, shots=shots)
+
+        payload = export_circuit_to_qasm(qiskit_circuit, self._export_format)
+
+        configuration_data = dict(self._configuration_data)
+        configuration_data["shots"] = int(shots)
+        config = JobSubmissionConfig(
+            backend_class_id=self._backend_class_id,
+            name="Qrisp Job",
+            job_subcategory_id=self._job_subcategory_id,
+            configuration_data=configuration_data,
+            organization_id=self._organization_id,
+            execution_plan=self._execution_plan,
+            queue_priority=self._queue_priority,
+            submitted_with="qrisp",
+            verbose=self._verbose,
+            job_timeout_seconds=self._job_timeout_seconds,
+        )
+        job = self._scheduler.submit_job(config, file_content=payload)
+        raw = self._scheduler.download_job_output(job)
+        counts = self._extract_counts(raw)
+        if self._reverse_bits:
+            counts = {k.replace(" ", "")[::-1]: v for k, v in counts.items()}
+        return counts, getattr(job, "id", None)
+
+    @staticmethod
+    def _extract_counts(raw: Any) -> Dict[str, int]:
+        """Pull the ``{bitstring: count}`` mapping out of a job output payload."""
+        if isinstance(raw, dict):
+            if "counts" in raw:
+                return raw["counts"]
+            if "measurement_counts" in raw:
+                return raw["measurement_counts"]
+            return raw
+        raise JobError(
+            f"Unexpected job output format: {type(raw).__name__}"
+        )

openquantum_sdk_qrisp-0.5.0/qrisp_openquantum/job.py

@@ -0,0 +1,52 @@
+"""Job handle returned by the Open Quantum Qrisp backend.
+
+Open Quantum job submission is synchronous: :meth:`SchedulerClient.submit_job`
+uploads the circuit, approves the quote, creates the job, and polls until it
+reaches a terminal state before returning. The Qrisp backend therefore does
+all of its work eagerly inside ``run_async`` and hands the finished counts to
+this job, which is already in the ``DONE`` state by the time the caller sees
+it.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from qrisp.interface import Job, JobResult, JobStatus
+
+
+class OpenQuantumJob(Job):
+    """A completed Open Quantum job wrapping one counts dict per circuit.
+
+    Args:
+        backend: The :class:`OpenQuantumBackend` that produced this job.
+        counts: One ``{bitstring: count}`` dict per submitted circuit, in
+            input order.
+        job_id: Optional platform job identifier (the id of the last
+            submitted circuit, for reference).
+    """
+
+    def __init__(
+        self,
+        backend,
+        counts: Sequence[dict],
+        job_id: str | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(backend, job_id=job_id, **kwargs)
+        self._counts = list(counts)
+        # Submission is synchronous, so the job is already finished.
+        self._last_known_status = JobStatus.DONE
+
+    def result(self, timeout: float | None = None) -> JobResult:
+        """Return the measurement results (job is already terminal)."""
+        self._raise_for_status()
+        return JobResult(self._counts)
+
+    def cancel(self) -> bool:
+        """Jobs are already terminal when returned, so there is nothing to cancel."""
+        return False
+
+    def status(self) -> JobStatus:
+        """Return the cached (terminal) status."""
+        return self._last_known_status

openquantum_sdk_qrisp-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openquantum_sdk_qrisp-0.5.0/tests/conftest.py

@@ -0,0 +1,71 @@
+"""Shared test fixtures for the OpenQuantum Qrisp backend."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from openquantum_sdk.clients import SchedulerClient
+from openquantum_sdk.models import JobRead
+
+
+SAMPLE_COUNTS = {"00": 512, "11": 512}
+
+
+@pytest.fixture
+def mock_scheduler() -> MagicMock:
+    """A mock SchedulerClient whose submit/download pipeline is stubbed."""
+    scheduler = MagicMock(spec=SchedulerClient)
+
+    mock_job = MagicMock(spec=JobRead)
+    mock_job.id = "job-123"
+    mock_job.status = "Completed"
+    mock_job.output_data_url = "https://example.com/output.json"
+
+    scheduler.submit_job.return_value = mock_job
+    scheduler.download_job_output.return_value = {"counts": dict(SAMPLE_COUNTS)}
+    return scheduler
+
+
+@pytest.fixture
+def mock_oq_backend() -> MagicMock:
+    """A mock capability-aware Qiskit backend (validation no-op).
+
+    ``transpile`` is the identity so submission/result-mapping tests keep
+    seeing the real circuit built by the ``to_qiskit`` stub.
+    """
+    oq_backend = MagicMock()
+    oq_backend.validate_circuit.return_value = None
+    oq_backend.transpile.side_effect = lambda circuit, **kwargs: circuit
+    return oq_backend
+
+
+@pytest.fixture
+def mock_service(mock_scheduler, mock_oq_backend) -> MagicMock:
+    """A mock OpenQuantumService exposing the scheduler and a backend factory."""
+    service = MagicMock()
+    service.scheduler = mock_scheduler
+    service.return_backend.return_value = mock_oq_backend
+    return service
+
+
+@pytest.fixture
+def two_qubit_circuit():
+    """A Qrisp circuit stand-in whose ``to_qiskit`` yields a real Bell circuit.
+
+    Using a stub keeps these unit tests focused on the plugin's submission and
+    result-mapping logic rather than Qrisp's circuit-construction API; the
+    live round-trip is covered by the integration test.
+    """
+    from qiskit import QuantumCircuit as QiskitCircuit
+
+    qc = QiskitCircuit(2, 2)
+    qc.h(0)
+    qc.cx(0, 1)
+    qc.measure(0, 0)
+    qc.measure(1, 1)
+
+    circuit = MagicMock()
+    circuit.to_qiskit.return_value = qc
+    return circuit

openquantum_sdk_qrisp-0.5.0/tests/test_backend.py

@@ -0,0 +1,262 @@
+"""Unit tests for the OpenQuantum Qrisp backend (mocked platform)."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from openquantum_sdk.exceptions import AuthenticationError, JobError
+
+from qrisp_openquantum import OpenQuantumBackend, OpenQuantumJob
+
+
+def _make_backend(mock_service, **kwargs):
+    return OpenQuantumBackend(backend="ionq:aria-1", service=mock_service, **kwargs)
+
+
+def test_requires_backend(mock_service):
+    with pytest.raises(ValueError):
+        OpenQuantumBackend(backend="", service=mock_service)
+
+
+def test_rejects_bad_export_format(mock_service):
+    with pytest.raises(ValueError):
+        _make_backend(mock_service, export_format="qasm9")
+
+
+def test_run_async_returns_done_job(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service)
+    job = backend.run_async([two_qubit_circuit], shots=1024)
+
+    assert isinstance(job, OpenQuantumJob)
+    assert job.done()
+    assert job.result().all_counts == [{"00": 512, "11": 512}]
+
+
+def test_submission_metadata_and_shots(mock_service, two_qubit_circuit):
+    backend = _make_backend(
+        mock_service,
+        job_subcategory_id="ml:qcl",
+        execution_plan="private",
+        queue_priority="priority",
+    )
+    backend.run_async([two_qubit_circuit], shots=2048)
+
+    config = mock_service.scheduler.submit_job.call_args.args[0]
+    assert config.backend_class_id == "ionq:aria-1"
+    assert config.job_subcategory_id == "ml:qcl"
+    assert config.execution_plan == "private"
+    assert config.queue_priority == "priority"
+    assert config.submitted_with == "qrisp"
+    assert config.configuration_data["shots"] == 2048
+    assert config.verbose is False
+    assert config.job_timeout_seconds == 86_400
+
+
+def test_default_shots_used_when_unspecified(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service, shots=256)
+    backend.run_async([two_qubit_circuit])
+    config = mock_service.scheduler.submit_job.call_args.args[0]
+    assert config.configuration_data["shots"] == 256
+
+
+def test_circuit_is_validated(mock_service, mock_oq_backend, two_qubit_circuit):
+    backend = _make_backend(mock_service)
+    backend.run_async([two_qubit_circuit], shots=100)
+    mock_oq_backend.validate_circuit.assert_called_once()
+
+
+def test_composite_gate_transpiled_before_validation(mock_service, mock_oq_backend):
+    """Regression for #453.
+
+    Qrisp's high-level types emit composite gates (e.g. a 'QFT no swap_dg'
+    from QuantumFloat arithmetic). The backend must transpile to the device
+    basis before the capability validator runs, otherwise submission fails
+    client-side with "Custom gate ... is not supported".
+    """
+    from qiskit import QuantumCircuit as QiskitCircuit
+
+    raw = QiskitCircuit(2, 2)
+    block = QiskitCircuit(2, name="QFT no swap_dg")
+    block.h(0)
+    block.cp(0.5, 0, 1)
+    raw.append(block.to_gate(), [0, 1])
+    raw.measure([0, 1], [0, 1])
+
+    circuit = MagicMock()
+    circuit.to_qiskit.return_value = raw
+
+    # Emulate the Qiskit plugin: the validator rejects the composite gate,
+    # transpile decomposes it to in-basis ops.
+    def _reject_composite(circ, shots=None):
+        for instruction in circ.data:
+            if instruction.operation.name == "QFT no swap_dg":
+                raise ValueError(
+                    "Custom gate 'QFT no swap_dg' is not supported by backend"
+                )
+
+    mock_oq_backend.validate_circuit.side_effect = _reject_composite
+    mock_oq_backend.transpile.side_effect = lambda circ, **kwargs: circ.decompose()
+
+    backend = _make_backend(mock_service)
+    job = backend.run_async([circuit], shots=100)  # must not raise
+    assert job.done()
+
+    # Without the transpile step the same circuit is rejected, confirming the
+    # fix is what lets it through.
+    mock_oq_backend.transpile.side_effect = lambda circ, **kwargs: circ
+    with pytest.raises(ValueError, match="QFT no swap_dg"):
+        backend.run_async([circuit], shots=100)
+
+
+def test_batch_submits_each_circuit(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service)
+    job = backend.run_async([two_qubit_circuit, two_qubit_circuit], shots=100)
+    assert mock_service.scheduler.submit_job.call_count == 2
+    assert job.result().num_circuits == 2
+
+
+def test_per_circuit_shots_length_mismatch(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service)
+    with pytest.raises(ValueError):
+        backend.run_async([two_qubit_circuit], shots=[100, 200])
+
+
+def test_reverse_bits(mock_service, two_qubit_circuit):
+    mock_service.scheduler.download_job_output.return_value = {"counts": {"01": 10}}
+    backend = _make_backend(mock_service, reverse_bits=True)
+    job = backend.run_async([two_qubit_circuit], shots=10)
+    assert job.result().get_counts() == {"10": 10}
+
+
+def test_raw_counts_without_counts_key(mock_service, two_qubit_circuit):
+    mock_service.scheduler.download_job_output.return_value = {"00": 5, "11": 5}
+    backend = _make_backend(mock_service)
+    job = backend.run_async([two_qubit_circuit], shots=10)
+    assert job.result().get_counts() == {"00": 5, "11": 5}
+
+
+def test_configuration_data_passthrough(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service, configuration_data={"engine": "amber_quantum_rings"})
+    backend.run_async([two_qubit_circuit], shots=100)
+    config = mock_service.scheduler.submit_job.call_args.args[0]
+    assert config.configuration_data["engine"] == "amber_quantum_rings"
+    assert config.configuration_data["shots"] == 100
+
+
+def test_flatten_registers_collapses_multiple_registers():
+    """Qrisp emits one register per qubit; the platform needs a single qreg."""
+    from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+
+    qc = QuantumCircuit(QuantumRegister(1, "a"), QuantumRegister(1, "b"),
+                        ClassicalRegister(1, "ca"), ClassicalRegister(1, "cb"))
+    qc.h(0)
+    qc.cx(0, 1)
+    qc.measure(0, 0)
+    qc.measure(1, 1)
+    assert len(qc.qregs) == 2
+
+    flat = OpenQuantumBackend._flatten_registers(qc)
+    assert len(flat.qregs) == 1
+    assert len(flat.cregs) == 1
+    assert flat.num_qubits == 2 and flat.num_clbits == 2
+
+
+def test_flatten_registers_noop_for_single_register():
+    from qiskit import QuantumCircuit
+
+    qc = QuantumCircuit(2, 2)
+    qc.h(0)
+    assert OpenQuantumBackend._flatten_registers(qc) is qc
+
+
+def test_measurement_counts_key(mock_service, two_qubit_circuit):
+    mock_service.scheduler.download_job_output.return_value = {
+        "measurement_counts": {"00": 7, "11": 3}
+    }
+    backend = _make_backend(mock_service)
+    job = backend.run_async([two_qubit_circuit], shots=10)
+    assert job.result().get_counts() == {"00": 7, "11": 3}
+
+
+def test_unexpected_output_format_raises(mock_service, two_qubit_circuit):
+    mock_service.scheduler.download_job_output.return_value = ["not", "a", "dict"]
+    backend = _make_backend(mock_service)
+    with pytest.raises(JobError, match="Unexpected job output format"):
+        backend.run_async([two_qubit_circuit], shots=10)
+
+
+def test_job_timeout_seconds_passthrough(mock_service, two_qubit_circuit):
+    backend = _make_backend(mock_service, job_timeout_seconds=600, verbose=True)
+    backend.run_async([two_qubit_circuit], shots=10)
+    config = mock_service.scheduler.submit_job.call_args.args[0]
+    assert config.job_timeout_seconds == 600
+    assert config.verbose is True
+
+
+def test_backend_property_alias(mock_service):
+    backend = _make_backend(mock_service)
+    assert backend.backend == "ionq:aria-1"
+    assert backend.backend_class_id == "ionq:aria-1"
+
+
+def test_auth_resolution_via_env(monkeypatch, two_qubit_circuit):
+    """With no service passed, the backend resolves creds through the core path."""
+    import qrisp_openquantum.backend as backend_mod
+
+    captured = {}
+    _Orig = backend_mod.OpenQuantumService
+
+    class _FakeService(_Orig):
+        def __init__(self, **kwargs):
+            captured.update(kwargs)
+            self.scheduler = _make_fake_scheduler()
+
+        def return_backend(self, *args, **kwargs):
+            oq = MagicMock()
+            oq.validate_circuit.return_value = None
+            oq.transpile.side_effect = lambda circuit, **kw: circuit
+            return oq
+
+    monkeypatch.setattr(backend_mod, "OpenQuantumService", _FakeService)
+    monkeypatch.delenv("OPENQUANTUM_TOKEN", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_SDK_KEY", raising=False)
+    monkeypatch.setenv("OPENQUANTUM_CLIENT_ID", "cid")
+    monkeypatch.setenv("OPENQUANTUM_CLIENT_SECRET", "secret")
+
+    backend = OpenQuantumBackend(backend="ionq:aria-1")
+    job = backend.run_async([two_qubit_circuit], shots=10)
+    assert job.done()
+    assert captured["creds"].client_id == "cid"
+    assert captured["token"] is None
+
+
+def test_auth_missing_raises(monkeypatch):
+    monkeypatch.delenv("OPENQUANTUM_TOKEN", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_CLIENT_ID", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_CLIENT_SECRET", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_SDK_KEY", raising=False)
+    with pytest.raises(AuthenticationError):
+        OpenQuantumBackend(backend="ionq:aria-1")
+
+
+def test_token_and_credentials_raises(monkeypatch):
+    monkeypatch.delenv("OPENQUANTUM_TOKEN", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_CLIENT_ID", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_CLIENT_SECRET", raising=False)
+    monkeypatch.delenv("OPENQUANTUM_SDK_KEY", raising=False)
+    with pytest.raises(ValueError, match="not both"):
+        OpenQuantumBackend(
+            backend="ionq:aria-1",
+            token="tok",
+            client_id="cid",
+            client_secret="secret",
+        )
+
+
+def _make_fake_scheduler():
+    scheduler = MagicMock()
+    scheduler.submit_job.return_value = MagicMock(id="job-1")
+    scheduler.download_job_output.return_value = {"counts": {"00": 512, "11": 512}}
+    return scheduler

openquantum_sdk_qrisp-0.5.0/tests/test_integration.py

@@ -0,0 +1,100 @@
+"""Opt-in live integration test for the OpenQuantum Qrisp backend.
+
+Runs real Qrisp programs against the platform. Skipped unless credentials and a
+target backend are provided via environment variables:
+
+    OPENQUANTUM_TOKEN         (or OPENQUANTUM_CLIENT_ID + OPENQUANTUM_CLIENT_SECRET)
+    OPENQUANTUM_TEST_BACKEND  e.g. "qr:gpu-gb10"
+
+Optional overrides for a non-production environment:
+
+    OPENQUANTUM_SCHEDULER_URL, OPENQUANTUM_MANAGEMENT_URL,
+    OPENQUANTUM_KEYCLOAK_BASE, OPENQUANTUM_ORGANIZATION_ID,
+    OPENQUANTUM_TEST_ENGINE (configuration_data engine, default
+    "amber_quantum_rings" for qr:gpu-gb10)
+
+This exercises the full path, including Qrisp circuit construction,
+``to_qiskit()`` conversion, and bit-order handling against real counts.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+HAS_AUTH = bool(
+    os.environ.get("OPENQUANTUM_TOKEN")
+    or (
+        os.environ.get("OPENQUANTUM_CLIENT_ID")
+        and os.environ.get("OPENQUANTUM_CLIENT_SECRET")
+    )
+)
+TEST_BACKEND = os.environ.get("OPENQUANTUM_TEST_BACKEND")
+
+pytestmark = pytest.mark.skipif(
+    not (HAS_AUTH and TEST_BACKEND),
+    reason="Set OPENQUANTUM_TOKEN (or client id/secret) and "
+    "OPENQUANTUM_TEST_BACKEND to run the live integration test.",
+)
+
+
+def _make_backend(**extra):
+    from qrisp_openquantum import OpenQuantumBackend
+
+    kwargs = dict(extra)
+    for env, arg in (
+        ("OPENQUANTUM_SCHEDULER_URL", "scheduler_url"),
+        ("OPENQUANTUM_MANAGEMENT_URL", "management_url"),
+        ("OPENQUANTUM_KEYCLOAK_BASE", "keycloak_base"),
+        ("OPENQUANTUM_ORGANIZATION_ID", "organization_id"),
+    ):
+        if os.environ.get(env):
+            kwargs[arg] = os.environ[env]
+    # Only the free Quantum Rings simulator requires an engine. Other
+    # backends reject unknown configuration keys, so do not inject one
+    # unless the caller asked for it or the target is qr:gpu-gb10.
+    engine = os.environ.get("OPENQUANTUM_TEST_ENGINE")
+    if engine is None and TEST_BACKEND == "qr:gpu-gb10":
+        engine = "amber_quantum_rings"
+    if engine:
+        kwargs.setdefault("configuration_data", {"engine": engine})
+    kwargs.setdefault("shots", 1024)
+    return OpenQuantumBackend(backend=TEST_BACKEND, **kwargs)
+
+
+def test_bell_state_live():
+    from qrisp import QuantumVariable, h, cx
+
+    oq = _make_backend()
+
+    qv = QuantumVariable(2)
+    h(qv[0])
+    cx(qv[0], qv[1])
+
+    result = qv.get_measurement(backend=oq, shots=1024)
+
+    # Bell state: outcomes concentrate on "00" and "11".
+    assert isinstance(result, dict)
+    assert sum(result.values()) == pytest.approx(1.0, abs=1e-6)
+    dominant = {k for k, v in result.items() if v > 0.1}
+    assert dominant.issubset({"00", "11"})
+
+
+def test_asymmetric_state_live():
+    """Prepare a QuantumFloat set to 6 and confirm Qrisp's decode end to end.
+
+    A palindromic Bell pair cannot reveal bit ordering. 6 is 110b; the
+    bit-reversed value is 3 (011b), so a wrong reverse_bits default would
+    decode as 3.
+    """
+    from qrisp import QuantumFloat
+
+    oq = _make_backend(shots=512)
+    a = QuantumFloat(3)
+    a[:] = 6
+    result = a.get_measurement(backend=oq, shots=512)
+
+    assert isinstance(result, dict)
+    top = max(result, key=result.get)
+    assert int(top) == 6