Metadata-Version: 2.4
Name: qdsv-runtime
Version: 0.2.0a1
Summary: QDSV Runtime Alpha: the public execution shell for canonical QDSV operation programs.
Project-URL: Homepage, https://qdsv.cloud/
Project-URL: Source, https://github.com/qdsvquantum-afk/qdsv-runtime
Project-URL: QIntent, https://qdsvquantum-afk.github.io/qintent/
Project-URL: Bridge, https://qdsvquantum-afk.github.io/qdsv-bridge/
Project-URL: Qruba, https://qdsvquantum-afk.github.io/qruba/
Author: QDSV / Qruba
License-Expression: MIT
License-File: LICENSE
Keywords: bridge,qdsv,qintent,quantum-software,runtime,semantic-workflows
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.9
Requires-Dist: qdsv-bridge>=0.2.0
Requires-Dist: qdsv-qintent>=0.1.11
Description-Content-Type: text/markdown

# QDSV Runtime Alpha

[![Status](https://img.shields.io/badge/status-alpha-f59e0b.svg)](#public-alpha-scope)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

**QDSV Runtime Alpha** is the public execution shell for problem-first QDSV workflows. Its canonical engine is **QDSV Operation Compiler v1**.

It ties together the public QDSV developer stack:

```text
QIntent -> ProblemSpec -> QDSV Runtime Alpha / Operation Compiler -> operation program
                                                               -> Bridge -> OpenQASM / Qiskit
                                                               -> backend execution + evidence

Qruba -> visual orchestration over the same Runtime/Compiler path
QDSV -> semantic model and private compiler implementation
```

Runtime Alpha does **not** embed or expose the private QDSV compiler implementation. It calls the canonical compiler API, records a safe operation-program passport and program digest, and then allows adapters such as Bridge to export the same compiled intent.

## Install

For local development:

```bash
pip install -e .
```

When published:

```bash
pip install qdsv-runtime
```

Before the PyPI release, users can install from GitHub after the public repository is created:

```bash
pip install git+https://github.com/qdsvquantum-afk/qdsv-runtime.git
```

## CLI Quickstart

Create a workspace:

```bash
qdsv init
```

Validate a QIntent file:

```bash
qdsv validate examples/basic.qintent
```

Compile QIntent into the canonical operation program:

```bash
qdsv compile-intent examples/basic.qintent --rows examples/rows.json
```

Compile a canonical ProblemSpec directly:

```bash
qdsv compile examples/problem.json
```

QIntent compilation is available through the controlled public preview quota. Direct arbitrary ProblemSpec compilation requires an authorized deployment or a local/private QDSV node because it exposes a broader expert surface.

Build a Bridge artifact from a supported Bridge spec:

```bash
qdsv build examples/bridge_spec.json --target bridge
```

Generate a local runtime report:

```bash
qdsv report
```

Docker/private demo images can also include the same CLI:

```bash
docker exec qruba-api-private qdsv --help
```

## Python SDK

```python
from qdsv_runtime import QDSVRuntime

runtime = QDSVRuntime()
runtime.init_workspace()
runtime.validate_intent("examples/basic.qintent")
runtime.compile_intent("examples/basic.qintent", rows_path="examples/rows.json")
runtime.compile_problem("examples/problem.json")
runtime.build_bridge("examples/bridge_spec.json")
runtime.write_report()
```

## Public Alpha Scope

This alpha includes:

- workspace creation;
- QIntent-to-operation-program compilation through the canonical engine;
- direct ProblemSpec-to-operation-program compilation;
- Bridge export backed by the same compiler authority;
- safe program digests, capability status, resource summaries and verification status;
- local artifact storage;
- reproducibility report generation;
- CLI commands for small examples.

This alpha does **not** include:

- private QDSV Runtime internals;
- semantic compiler internals;
- lowering logic;
- backend selection internals;
- private scoring formulas;
- production scheduler;
- user/tenant management;
- marketplace/plugins;
- local execution of the private semantic engine.

## Positioning

QDSV Runtime Alpha is not a quantum operating system and Bridge is not its engine. Runtime is the executable product layer around the canonical QDSV operation program; QIntent formulates intent, Qruba orchestrates it, and Bridge exports compatible artifacts without creating a parallel compilation route.
