quapp 0.1.0__tar.gz

quapp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quapp CLI Contributors
+
+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.

quapp-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: quapp
+Version: 0.1.0
+Summary: CLI for the Quapp quantum/cloud computing platform
+License: MIT License
+        
+        Copyright (c) 2026 Quapp CLI Contributors
+        
+        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.
+        
+Project-URL: Homepage, https://gitlab.com/quanghuy.ha/Quapp-CLI
+Project-URL: Repository, https://gitlab.com/quanghuy.ha/Quapp-CLI
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# Quapp CLI
+
+A command-line interface for the [Quapp](https://quapp.cloud) quantum/cloud computing platform.
+
+## Install
+
+```bash
+pip install quapp
+```
+
+Or download a standalone binary from the [GitLab CI pipeline artifacts](https://gitlab.com/quapp/quapp-cli/-/pipelines) — no Python required.
+
+## Quick Start
+
+```bash
+# Authenticate
+quapp auth login
+
+# Create a project
+quapp project create --name my-project
+
+# Create a function
+quapp function create --name my-func --sdk-version 0.45.3 --lang qiskit
+
+# Upload a function version
+quapp function version <function-id> --description "v1" --files main.py
+
+# Run a job
+quapp job run --function <function-id> --provider aws --device sim --shots 1000 --wait
+```
+
+## Commands
+
+### Auth
+```
+quapp auth login       Authenticate with email + password
+quapp auth logout      Invalidate session
+quapp auth status      Show login state
+```
+
+### Projects
+```
+quapp project create --name X [--description Y] [--permission private|group]
+quapp project get <id>
+quapp project delete <id>
+```
+
+### Functions
+```
+quapp function create --name X --sdk-version X --lang qiskit|cuda [--description Y]
+quapp function version <id> --description X --files file1.py [file2.py ...]
+quapp function get <id>
+quapp function delete <id>
+```
+
+### Jobs
+```
+quapp job run --function <id> --provider aws --device <device> --shots N [--wait]
+quapp job status <id>
+quapp job results <id>
+quapp job cancel <id>
+quapp job retry <id>
+```
+
+### Global flags
+```
+--json    Output raw JSON instead of Rich tables
+```
+
+## Development
+
+```bash
+pip install -e .
+python -m pytest tests/
+```
+
+## License
+
+MIT

quapp-0.1.0/README.md

@@ -0,0 +1,79 @@
+# Quapp CLI
+
+A command-line interface for the [Quapp](https://quapp.cloud) quantum/cloud computing platform.
+
+## Install
+
+```bash
+pip install quapp
+```
+
+Or download a standalone binary from the [GitLab CI pipeline artifacts](https://gitlab.com/quapp/quapp-cli/-/pipelines) — no Python required.
+
+## Quick Start
+
+```bash
+# Authenticate
+quapp auth login
+
+# Create a project
+quapp project create --name my-project
+
+# Create a function
+quapp function create --name my-func --sdk-version 0.45.3 --lang qiskit
+
+# Upload a function version
+quapp function version <function-id> --description "v1" --files main.py
+
+# Run a job
+quapp job run --function <function-id> --provider aws --device sim --shots 1000 --wait
+```
+
+## Commands
+
+### Auth
+```
+quapp auth login       Authenticate with email + password
+quapp auth logout      Invalidate session
+quapp auth status      Show login state
+```
+
+### Projects
+```
+quapp project create --name X [--description Y] [--permission private|group]
+quapp project get <id>
+quapp project delete <id>
+```
+
+### Functions
+```
+quapp function create --name X --sdk-version X --lang qiskit|cuda [--description Y]
+quapp function version <id> --description X --files file1.py [file2.py ...]
+quapp function get <id>
+quapp function delete <id>
+```
+
+### Jobs
+```
+quapp job run --function <id> --provider aws --device <device> --shots N [--wait]
+quapp job status <id>
+quapp job results <id>
+quapp job cancel <id>
+quapp job retry <id>
+```
+
+### Global flags
+```
+--json    Output raw JSON instead of Rich tables
+```
+
+## Development
+
+```bash
+pip install -e .
+python -m pytest tests/
+```
+
+## License
+
+MIT

quapp-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quapp"
+version = "0.1.0"
+description = "CLI for the Quapp quantum/cloud computing platform"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+dependencies = [
+    "typer[all]>=0.12",
+    "rich>=13",
+    "requests>=2.31",
+]
+
+[project.scripts]
+quapp = "quapp.cli.app:app"
+
+[project.urls]
+Homepage = "https://gitlab.com/quanghuy.ha/Quapp-CLI"
+Repository = "https://gitlab.com/quanghuy.ha/Quapp-CLI"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["quapp*"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

quapp-0.1.0/quapp/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

quapp-0.1.0/quapp/__main__.py

@@ -0,0 +1,4 @@
+from quapp.cli.app import app
+
+if __name__ == "__main__":
+    app()

quapp-0.1.0/quapp/api/auth.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from quapp.api.client import QuappClient
+
+
+def login(base_url: str, email: str, password: str) -> dict:
+    """POST /auth/login — returns {"accessToken": ..., "refreshToken": ...}."""
+    client = QuappClient(base_url)
+    response = client.post("/auth/login", json={"email": email, "password": password})
+    return response.json()
+
+
+def logout(base_url: str, token: str) -> None:
+    """POST /auth/logout — invalidates the refresh token server-side."""
+    client = QuappClient(base_url, token=token)
+    client.post("/auth/logout")

quapp-0.1.0/quapp/api/client.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import time
+
+import requests
+
+# ---------------------------------------------------------------------------
+# Typed exceptions
+# ---------------------------------------------------------------------------
+
+
+class QuappError(Exception):
+    """Base exception for all Quapp API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class QuappAuthError(QuappError):
+    """401 — Not logged in or token expired."""
+
+
+class QuappForbiddenError(QuappError):
+    """403 — Permission denied."""
+
+
+class QuappNotFoundError(QuappError):
+    """404 — Resource not found."""
+
+
+class QuappBadRequestError(QuappError):
+    """400 — Bad request / validation error."""
+
+
+class QuappRateLimitError(QuappError):
+    """429 — Rate limit exceeded (triggers retry)."""
+
+
+class QuappServerError(QuappError):
+    """500 / 503 — Server-side error."""
+
+
+_STATUS_MAP: dict[int, type[QuappError]] = {
+    400: QuappBadRequestError,
+    401: QuappAuthError,
+    403: QuappForbiddenError,
+    404: QuappNotFoundError,
+    429: QuappRateLimitError,
+    500: QuappServerError,
+    503: QuappServerError,
+}
+
+_RETRY_STATUSES = {429, 503}
+_MAX_RETRIES = 3
+_BACKOFF_BASE = 1.0  # seconds
+
+
+def _raise_for_status(response: requests.Response) -> None:
+    if response.ok:
+        return
+    code = response.status_code
+    try:
+        detail = response.json().get("message") or response.json().get("error") or response.text
+    except Exception:
+        detail = response.text
+
+    exc_class = _STATUS_MAP.get(code, QuappError)
+    default_msgs = {
+        401: "Not logged in or token expired. Run `quapp auth login`.",
+        403: "Permission denied.",
+        404: "Resource not found.",
+        429: f"Rate limit exceeded: {detail}",
+        500: "Quapp server error. Try again later.",
+        503: "Quapp server unavailable. Try again later.",
+    }
+    msg = default_msgs.get(code, detail or f"HTTP {code}")
+    raise exc_class(msg, status_code=code)
+
+
+# ---------------------------------------------------------------------------
+# Client
+# ---------------------------------------------------------------------------
+
+
+class QuappClient:
+    def __init__(self, base_url: str, token: str | None = None) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self._session = requests.Session()
+
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        retries: int = _MAX_RETRIES,
+        **kwargs,
+    ) -> requests.Response:
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        kwargs.setdefault("headers", {}).update(self._headers())
+        attempt = 0
+        while True:
+            response = self._session.request(method, url, **kwargs)
+            if response.status_code in _RETRY_STATUSES and attempt < retries:
+                wait = _BACKOFF_BASE * (2 ** attempt)
+                time.sleep(wait)
+                attempt += 1
+                continue
+            _raise_for_status(response)
+            return response
+
+    def get(self, path: str, **kwargs) -> requests.Response:
+        return self.request("GET", path, **kwargs)
+
+    def post(self, path: str, **kwargs) -> requests.Response:
+        return self.request("POST", path, **kwargs)
+
+    def delete(self, path: str, **kwargs) -> requests.Response:
+        return self.request("DELETE", path, **kwargs)

quapp-0.1.0/quapp/api/functions.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from quapp.api.client import QuappClient
+
+
+def create_function(
+    client: QuappClient,
+    name: str,
+    sdk_version: str,
+    lang: str,
+    description: str | None = None,
+) -> dict:
+    """POST /functions — create a new function and return the response dict."""
+    body: dict = {
+        "functionName": name,
+        "sdkVersion": sdk_version,
+        "templateLanguageTag": lang,
+    }
+    if description:
+        body["description"] = description
+    response = client.post("/functions", json=body)
+    return response.json()
+
+
+def create_function_version(
+    client: QuappClient,
+    function_id: str,
+    description: str | None,
+    files: list[dict],
+) -> dict:
+    """POST /functions/{id}/versions — create a new version and return the response dict."""
+    body: dict = {"templateFiles": files}
+    if description:
+        body["description"] = description
+    response = client.post(f"/functions/{function_id}/versions", json=body)
+    return response.json()
+
+
+def get_function(client: QuappClient, function_id: str) -> dict:
+    """GET /functions/{id} — return function details dict."""
+    response = client.get(f"/functions/{function_id}")
+    return response.json()
+
+
+def delete_function(client: QuappClient, function_id: str) -> None:
+    """DELETE /functions/{id} — delete a function; returns nothing."""
+    client.delete(f"/functions/{function_id}")

quapp-0.1.0/quapp/api/jobs.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from quapp.api.client import QuappClient
+
+
+def run_job(
+    client: QuappClient,
+    function_id: str,
+    provider: str,
+    device: str,
+    shots: int,
+) -> dict:
+    """POST /jobs — submit a job and return the response dict."""
+    body = {
+        "function_id": function_id,
+        "provider": provider,
+        "device": device,
+        "shots": shots,
+    }
+    response = client.post("/jobs", json=body)
+    return response.json()
+
+
+def get_job_status(client: QuappClient, job_id: str) -> dict:
+    """GET /jobs/{id} — return job status dict."""
+    response = client.get(f"/jobs/{job_id}")
+    return response.json()
+
+
+def get_job_results(client: QuappClient, job_id: str) -> dict:
+    """GET /jobs/{id}/results — return job results dict."""
+    response = client.get(f"/jobs/{job_id}/results")
+    return response.json()
+
+
+def cancel_job(client: QuappClient, job_id: str) -> None:
+    """DELETE /jobs/{id} — cancel a job; returns nothing."""
+    client.delete(f"/jobs/{job_id}")
+
+
+def retry_job(client: QuappClient, job_id: str) -> dict:
+    """POST /jobs/{id}/retry — retry a failed job and return the response dict."""
+    response = client.post(f"/jobs/{job_id}/retry")
+    return response.json()

quapp-0.1.0/quapp/api/projects.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from quapp.api.client import QuappClient
+
+
+def create_project(
+    client: QuappClient,
+    name: str,
+    description: str | None = None,
+    members: list[str] | None = None,
+    permission: str = "private",
+) -> dict:
+    """POST /projects — create a new project and return the response dict."""
+    body: dict = {"name": name, "permission": permission}
+    if description:
+        body["description"] = description
+    if members:
+        body["members"] = members
+    response = client.post("/projects", json=body)
+    return response.json() if response.content else {}
+
+
+def get_project(client: QuappClient, project_id: str) -> dict:
+    """GET /projects/{id} — return project details dict."""
+    response = client.get(f"/projects/{project_id}")
+    return response.json()
+
+
+def delete_project(client: QuappClient, project_id: str) -> None:
+    """DELETE /projects/{id} — delete a project; returns nothing."""
+    client.delete(f"/projects/{project_id}")

quapp-0.1.0/quapp/cli/app.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import typer
+
+from quapp import output
+from quapp.cli import auth, functions, jobs, projects
+
+app = typer.Typer(
+    name="quapp",
+    help="Quapp quantum/cloud computing platform CLI.",
+    no_args_is_help=True,
+)
+
+app.add_typer(auth.app, name="auth")
+app.add_typer(projects.app, name="project")
+app.add_typer(functions.app, name="function")
+app.add_typer(jobs.app, name="job")
+
+
+@app.callback()
+def main(
+    json: bool = typer.Option(False, "--json", help="Output raw JSON instead of Rich tables."),
+) -> None:
+    output.set_json_mode(json)

quapp-0.1.0/quapp/cli/auth.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import sys
+from typing import Annotated
+
+import typer
+
+from quapp import api
+from quapp.config import load_config, save_config
+from quapp import output
+
+app = typer.Typer(help="Manage authentication.")
+
+
+@app.command()
+def login() -> None:
+    """Authenticate with email + password and save token."""
+    config = load_config()
+    email = typer.prompt("Email")
+    password = typer.prompt("Password", hide_input=True)
+    try:
+        from quapp.api.auth import login as api_login
+        data = api_login(config.base_url, email, password)
+    except Exception as exc:
+        output.print_error(str(exc))
+        raise typer.Exit(1)
+
+    token = data.get("accessToken") or data.get("token")
+    if not token:
+        output.print_error("Login response did not contain an access token.")
+        raise typer.Exit(1)
+
+    config.token = token
+    save_config(config)
+
+    if output.is_json_mode():
+        output.print_json({"status": "logged_in", "email": email})
+    else:
+        output.print_success(f"Logged in as {email}.")
+
+
+@app.command()
+def logout() -> None:
+    """Invalidate session and clear local token."""
+    config = load_config()
+    if not config.token:
+        output.print_error("Not logged in.")
+        raise typer.Exit(1)
+    try:
+        from quapp.api.auth import logout as api_logout
+        api_logout(config.base_url, config.token)
+    except Exception as exc:
+        output.print_error(str(exc))
+        raise typer.Exit(1)
+    finally:
+        config.token = None
+        save_config(config)
+
+    if output.is_json_mode():
+        output.print_json({"status": "logged_out"})
+    else:
+        output.print_success("Logged out.")
+
+
+@app.command()
+def status() -> None:
+    """Show whether you are logged in."""
+    config = load_config()
+    if config.token:
+        if output.is_json_mode():
+            output.print_json({"logged_in": True})
+        else:
+            output.print_success("Logged in.")
+    else:
+        if output.is_json_mode():
+            output.print_json({"logged_in": False})
+        else:
+            output.print_error("Not logged in. Run `quapp auth login`.")