lr-qrm 0.1.0__py3-none-any.whl

lr_qrm-0.1.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: lr-qrm
+Version: 0.1.0
+Summary: CLI client for interacting with Qestit QRM data from LumenRadio tooling.
+Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
+License: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.7
+Requires-Dist: pydantic>=2.8
+Provides-Extra: dev
+Requires-Dist: build>=1.2.1; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pytest>=8.4.2; extra == "dev"
+Requires-Dist: black>=25.9.0; extra == "dev"
+Requires-Dist: pytest-html; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# QRM
+
+CLI + Python client for interacting with the Qestit QRM.
+
+## Install
+
+```bash
+pip install lr-qrm
+```
+
+## Quick start
+
+### Login
+
+Interactive login (prompts for username/password):
+
+```bash
+qrm login
+```
+
+Non-interactive (for CI/CD):
+
+```bash
+export QRM_USERNAME="<insert username>"
+export QRM_PASSWORD="<insert password>"
+qrm login --ci
+```
+
+By default, this stores session details at:
+
+```
+~/.config/qrm/login.json
+```
+
+### Commands
+
+
+Get test results for a serial number.
+
+```bash
+qrm get-test-results P00Y00000001
+```
+
+
+#### JSON output
+
+Most commands support a JSON output mode.
+
+
+```bash
+$ qrm get-test-results P00Y00000001 --format json
+```
+
+## Programmatic use
+
+```python
+from qrm import QrmClient, load_config
+
+client = QrmClient(load_config())
+results = client.get_test_results("P00Y00000001")
+```
+
+
+## FAQ
+
+- **Where is the config kept?**
+  `~/.config/qrm/login.json` (override with `QRM_CONFIG`)
+
+- **How do I run non-interactively?**
+  Make sure to give all required arguments. Also pass `--ci` to stop output of sensitive information such as username or passwords.

lr_qrm-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+lr_qrm-0.1.0.dist-info/licenses/LICENSE,sha256=cEnG3HeMPa3GKtuENkytOQaNJS9rwMMU_KWHObdWbOY,1070
+qrm/__init__.py,sha256=vpsqqB9AKEhCcTdlSNeMF74vKSUG2NuUPEd5uE6u-ws,1069
+qrm/cli.py,sha256=M3f6D5_ROssysCWsWhbdMgsNJOaDWQZux5u5D0LE6II,10602
+qrm/client.py,sha256=-wA06kxdOx1y4xlPASfwFzltUZaFt4KeDqbgMBY8QCY,5979
+qrm/config.py,sha256=TewatdLxqbCa7hBLbqj8hrKbposvbD-Wc1TSiUipzq4,623
+lr_qrm-0.1.0.dist-info/METADATA,sha256=Xa_NmdCeaKlqLa3wqri7Nb8cmGQVeCWUuqcpUhkpnUw,1841
+lr_qrm-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lr_qrm-0.1.0.dist-info/entry_points.txt,sha256=9CaqYoIqOC9O40WoJ6SM1qYk9gP5VVShmMc51zBqas4,36
+lr_qrm-0.1.0.dist-info/top_level.txt,sha256=URCUvNbN-7KWypbbmrCaie8JjKDowz0p4GNhBqnN99U,4
+lr_qrm-0.1.0.dist-info/RECORD,,

lr_qrm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lr_qrm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qrm = qrm.cli:app

lr_qrm-0.1.0.dist-info/licenses/LICENSE

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

lr_qrm-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qrm

qrm/__init__.py

@@ -0,0 +1,38 @@
+"""Top-level package for the lr-qrm CLI."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as package_version
+from pathlib import Path
+
+from .client import LoginState, QrmClient, QrmClientError
+
+
+def _load_version() -> str:
+    try:
+        return package_version("lr-qrm")
+    except PackageNotFoundError:
+        return _version_from_pyproject()
+
+
+def _version_from_pyproject() -> str:
+    pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+    if not pyproject.exists():  # pragma: no cover - defensive guard
+        raise RuntimeError("pyproject.toml not found; unable to determine version")
+
+    for raw_line in pyproject.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if line.startswith("version ="):
+            return line.split("=", 1)[1].strip().strip('"').strip("'")
+
+    raise RuntimeError("Version not declared in pyproject.toml")
+
+
+__version__ = _load_version()
+
+__all__ = [
+    "__version__",
+    "LoginState",
+    "QrmClient",
+    "QrmClientError",
+]

qrm/cli.py

@@ -0,0 +1,349 @@
+"""Typer-powered CLI entry point for lr-qrm."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from . import __version__
+from .client import LoginState, QrmClient, QrmClientError
+from .config import load_login_state
+
+DEFAULT_BASE_URL = "https://qrm.lumenradio.com/api"
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "qrm" / "login.json"
+
+
+class OutputFormat(str, Enum):
+    rich = "rich"
+    json = "json"
+
+
+app = typer.Typer(help="Interact with the Qestit QRM service.")
+console = Console()
+uut_app = typer.Typer(help="Inspect Units Under Test (UUTs).")
+app.add_typer(uut_app, name="uut")
+
+UUT_API_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+UUT_CLI_DATE_FORMATS = [
+    UUT_API_DATE_FORMAT,
+    "%Y-%m-%dT%H:%M:%S",
+    "%Y-%m-%dT%H:%M:%S%z",
+]
+UUT_DEFAULT_WINDOW = timedelta(days=1)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Display the lr-qrm version and exit.",
+        rich_help_panel="Global Options",
+    ),
+) -> None:
+    """Top-level callback showing help or version when requested."""
+
+    if version:
+        typer.echo(__version__)
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+@app.command()
+def status(
+    config_path: Path = typer.Option(
+        None,
+        "--config-path",
+        help="Override the location of the login.json file.",
+    ),
+    base_url: str = typer.Option(
+        None,
+        "--base-url",
+        help="Override the base URL stored in the config (useful for testing).",
+    ),
+    insecure: bool = typer.Option(
+        False,
+        "--insecure",
+        help="Disable TLS verification when contacting QRM.",
+    ),
+    output: OutputFormat = typer.Option(
+        OutputFormat.rich,
+        "--output",
+        "-o",
+        case_sensitive=False,
+        help="Choose output format: rich (default) or json.",
+    ),
+) -> None:
+    """Check QRM health via the `/Result/Status` endpoint."""
+
+    state = _load_state_or_exit(config_path)
+
+    client = QrmClient(
+        base_url=base_url or str(state.base_url),
+        verify_tls=not insecure and state.verify_tls,
+    )
+
+    try:
+        payload = client.status(token=state.token)
+    except QrmClientError as exc:
+        typer.secho(f"Status check failed: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+    _emit(payload, output)
+
+
+@app.command()
+def login(
+    username: str = typer.Option(..., "--username", "-u", prompt=True, help="QRM username."),
+    password: str = typer.Option(
+        ..., "--password", "-p", prompt=True, hide_input=True, help="QRM password."
+    ),
+    base_url: str = typer.Option(
+        DEFAULT_BASE_URL,
+        "--base-url",
+        "-b",
+        help="Base URL for the QRM API.",
+    ),
+    config_path: Path = typer.Option(
+        None,
+        "--config-path",
+        help="Override the location of the login.json file.",
+    ),
+    insecure: bool = typer.Option(
+        False,
+        "--insecure",
+        help="Disable TLS verification when contacting QRM.",
+    ),
+    output: OutputFormat = typer.Option(
+        OutputFormat.rich,
+        "--output",
+        "-o",
+        case_sensitive=False,
+        help="Choose output format: rich (default) or json.",
+    ),
+) -> None:
+    """Authenticate against QRM and store the bearer token locally."""
+
+    destination = _resolve_config_path(config_path)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    client = QrmClient(base_url=base_url, verify_tls=not insecure)
+    try:
+        token = client.login(username=username, password=password)
+    except QrmClientError as exc:
+        typer.secho(f"Login failed: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+    state = LoginState(
+        token=token,
+        username=username,
+        base_url=base_url,
+        verify_tls=not insecure,
+    )
+    destination.write_text(state.model_dump_json(indent=2), encoding="utf-8")
+
+    message = f"[green]Stored login token for {username} at {destination}[/green]"
+    payload = {
+        "username": username,
+        "config_path": str(destination),
+    }
+    _emit(payload if output is OutputFormat.json else message, output)
+
+
+@uut_app.command("status")
+def uut_status(
+    serial_number: str = typer.Argument(..., help="Serial number to query."),
+    start: datetime | None = typer.Option(
+        None,
+        "--start",
+        formats=UUT_CLI_DATE_FORMATS,
+        help="Filter from this timestamp (UTC). Format: YYYY-MM-DD HH:MM:SS. Default: stop - 1 day.",
+    ),
+    stop: datetime | None = typer.Option(
+        None,
+        "--stop",
+        formats=UUT_CLI_DATE_FORMATS,
+        help="Filter until this timestamp (UTC). Format: YYYY-MM-DD HH:MM:SS. Default: now.",
+    ),
+    max_results: int = typer.Option(
+        1000,
+        "--max-results",
+        "-m",
+        min=1,
+        max=5000,
+        help="Maximum number of rows to return (default 1000).",
+    ),
+    config_path: Path = typer.Option(
+        None,
+        "--config-path",
+        help="Override the location of the login.json file.",
+    ),
+    base_url: str = typer.Option(
+        None,
+        "--base-url",
+        help="Override the base URL stored in the config (useful for testing).",
+    ),
+    insecure: bool = typer.Option(
+        False,
+        "--insecure",
+        help="Disable TLS verification when contacting QRM.",
+    ),
+    output: OutputFormat = typer.Option(
+        OutputFormat.rich,
+        "--output",
+        "-o",
+        case_sensitive=False,
+        help="Choose output format: rich (default) or json.",
+    ),
+) -> None:
+    """Fetch UUT execution history using the `/Uut/Status` endpoint."""
+
+    state = _load_state_or_exit(config_path)
+    start, stop = _resolve_uut_window(start, stop)
+
+    client = QrmClient(
+        base_url=base_url or str(state.base_url),
+        verify_tls=not insecure and state.verify_tls,
+    )
+
+    try:
+        payload = client.uut_status(
+            token=state.token,
+            serial_number=serial_number,
+            start_datetime=_format_uut_datetime(start),
+            stop_datetime=_format_uut_datetime(stop),
+            max_results=max_results,
+        )
+    except QrmClientError as exc:
+        typer.secho(f"UUT status check failed: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+    if output is OutputFormat.json:
+        _emit(payload, output)
+        return
+
+    console.print(_render_uut_status(payload))
+
+
+def _resolve_config_path(config_path: Path | None) -> Path:
+    return config_path.expanduser() if config_path else DEFAULT_CONFIG_PATH
+
+
+def _load_state_or_exit(config_path: Path | None) -> LoginState:
+    try:
+        return load_login_state(_resolve_config_path(config_path))
+    except FileNotFoundError:
+        typer.secho(
+            "No login state found. Please run `qrm login` first or provide --config-path.",
+            fg=typer.colors.RED,
+        )
+        raise typer.Exit(code=1)
+    except Exception as exc:  # pragma: no cover - defensive guard
+        typer.secho(f"Could not read login state: {exc}", fg=typer.colors.RED)
+        raise typer.Exit(code=1) from exc
+
+
+def _emit(payload: Any, output: OutputFormat) -> None:
+    if output is OutputFormat.json:
+        typer.echo(json.dumps(payload))
+        return
+
+    if isinstance(payload, str):
+        console.print(payload)
+        return
+
+    if isinstance(payload, dict):
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Field", style="cyan", no_wrap=True)
+        table.add_column("Value", style="green")
+        for key, value in payload.items():
+            table.add_row(str(key), json.dumps(value) if isinstance(value, (dict, list)) else str(value))
+        console.print(table)
+        return
+
+    console.print(payload)
+
+
+def _resolve_uut_window(
+    start: datetime | None,
+    stop: datetime | None,
+) -> tuple[datetime, datetime]:
+    stop_value = stop or datetime.now(timezone.utc)
+    start_value = start or (stop_value - UUT_DEFAULT_WINDOW)
+    return start_value, stop_value
+
+
+def _format_uut_datetime(value: datetime | None) -> str | None:
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        return value.strftime(UUT_API_DATE_FORMAT)
+    return value.astimezone(timezone.utc).strftime(UUT_API_DATE_FORMAT)
+
+
+def _render_uut_status(payload: Any) -> Table:
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Result Set", style="cyan")
+    table.add_column("Serial", style="cyan")
+    table.add_column("Outcome", style="green")
+    table.add_column("Start", style="magenta")
+    table.add_column("Stop", style="magenta")
+    table.add_column("Station", style="yellow")
+    table.add_column("Operator", style="yellow")
+
+    rows = payload if isinstance(payload, list) else ([payload] if payload else [])
+
+    if not rows:
+        table.add_row("No results", "-", "-", "-", "-", "-", "-")
+        return table
+
+    for entry in rows:
+        if not isinstance(entry, dict):
+            table.add_row(str(entry), "-", "-", "-", "-", "-", "-")
+            continue
+
+        info = entry.get("Info") if isinstance(entry.get("Info"), dict) else {}
+        table.add_row(
+            str(entry.get("ResultSetName") or entry.get("Id", "-")),
+            str(info.get("UutSerialNumber") or entry.get("SerialNumber", _resolve_serial(entry))),
+            str(entry.get("Outcome", "-")),
+            _format_timestamp(entry.get("StartDateTime")),
+            _format_timestamp(entry.get("StopDateTime")),
+            str(info.get("StationName") or "-"),
+            str(info.get("Operator") or "-"),
+        )
+
+    return table
+
+
+def _resolve_serial(entry: dict[str, Any]) -> str:
+    value = entry.get("serialNumber") or entry.get("SerialNumber")
+    return str(value) if value else "-"
+
+
+def _format_timestamp(value: Any) -> str:
+    if not value:
+        return "-"
+    if isinstance(value, str):
+        sanitized = value.replace("Z", "+00:00") if value.endswith("Z") else value
+        try:
+            dt = datetime.fromisoformat(sanitized)
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            return value
+    if isinstance(value, datetime):
+        return value.strftime("%Y-%m-%d %H:%M:%S")
+    return str(value)
+
+
+__all__ = ["app"]

qrm/client.py

@@ -0,0 +1,183 @@
+"""HTTP client helpers for QRM services."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+from urllib.parse import urljoin
+
+import requests
+import urllib3
+from pydantic import BaseModel, Field, HttpUrl
+
+
+class LoginCredentials(BaseModel):
+    """Payload accepted by the `/User/Login` endpoint."""
+
+    username: str = Field(..., min_length=1)
+    password: str = Field(..., min_length=1)
+
+
+class LoginState(BaseModel):
+    """Serialized login state saved on disk by the CLI."""
+
+    token: str = Field(..., min_length=1)
+    username: str = Field(..., min_length=1)
+    base_url: HttpUrl
+    verify_tls: bool = True
+    stored_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class QrmClientError(RuntimeError):
+    """Raised when the client cannot fulfill a request."""
+
+
+@dataclass
+class QrmClient:
+    """Thin wrapper around the QRM HTTP API."""
+
+    base_url: str
+    verify_tls: bool = True
+    timeout: float = 10.0
+    session: Optional[requests.Session] = None
+
+    def __post_init__(self) -> None:
+        if not self.base_url:
+            raise ValueError("base_url must be provided")
+        self.base_url = self.base_url.rstrip("/")
+        self.session = self.session or requests.Session()
+        self.session.verify = self.verify_tls
+        if not self.verify_tls:
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+    def login(self, username: str, password: str) -> str:
+        """Authenticate against `/User/Login` and return the bearer token."""
+
+        credentials = LoginCredentials(username=username, password=password)
+        try:
+            response = self.session.post(
+                self._build_url("/User/Login"),
+                json=credentials.model_dump(),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            raise QrmClientError("Failed to contact QRM login endpoint") from exc
+
+        token = self._extract_token(response)
+        if not token:
+            raise QrmClientError("QRM login response did not contain a token")
+        return token
+
+    def status(self, token: Optional[str] = None) -> Any:
+        """Query the `/Result/Status` endpoint to verify service health."""
+
+        headers = {"Authorization": f"Bearer {token}"} if token else None
+        try:
+            response = self.session.get(
+                self._build_url("/Result/Status"),
+                headers=headers,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            raise QrmClientError("Failed to contact QRM status endpoint") from exc
+
+        try:
+            return response.json()
+        except ValueError:
+            return response.text.strip()
+
+    def uut_status(
+        self,
+        *,
+        token: str,
+        serial_number: str,
+        start_datetime: Optional[str] = None,
+        stop_datetime: Optional[str] = None,
+        max_results: Optional[int] = None,
+    ) -> Any:
+        """Query the `/Uut/Status` endpoint for unit test history."""
+
+        if not serial_number:
+            raise ValueError("serial_number must be provided")
+        headers = {"Authorization": f"Bearer {token}"}
+        payload: Dict[str, Any] = {
+            "serialNumber": serial_number,
+        }
+        if start_datetime:
+            payload["startDateTime"] = start_datetime
+        if stop_datetime:
+            payload["stopDateTime"] = stop_datetime
+        if max_results is not None:
+            payload["maxNumberOfResults"] = max_results
+
+        try:
+            response = self.session.post(
+                self._build_url("/Uut/Status"),
+                headers=headers,
+                json=payload,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            raise QrmClientError("Failed to contact QRM UUT status endpoint") from exc
+
+        try:
+            return response.json()
+        except ValueError:
+            return response.text.strip()
+
+    def _build_url(self, path: str) -> str:
+        return urljoin(f"{self.base_url}/", path.lstrip("/"))
+
+    @staticmethod
+    def _extract_token(response: requests.Response) -> Optional[str]:
+        payload: Any
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = None
+
+        token = QrmClient._token_from_payload(payload)
+        if token:
+            return token
+
+        fallback = response.text.strip()
+        if fallback:
+            token = QrmClient._token_from_payload(fallback)
+            if token:
+                return token
+            return fallback
+        return None
+
+    @staticmethod
+    def _token_from_payload(payload: Any) -> Optional[str]:
+        if isinstance(payload, Dict):
+            for key in (
+                "token",
+                "Token",
+                "accessToken",
+                "access_token",
+                "bearerToken",
+                "value",
+            ):
+                value = payload.get(key)
+                if isinstance(value, str) and value.strip():
+                    return value.strip()
+        if isinstance(payload, str):
+            trimmed = payload.strip()
+            if not trimmed:
+                return None
+            if trimmed.startswith("{") and trimmed.endswith("}"):
+                try:
+                    return QrmClient._token_from_payload(json.loads(trimmed))
+                except json.JSONDecodeError:
+                    pass
+            return trimmed
+        return None
+
+
+__all__ = ["LoginCredentials", "LoginState", "QrmClient", "QrmClientError"]

qrm/config.py

@@ -0,0 +1,26 @@
+"""Helpers for loading persisted QRM CLI configuration."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .client import LoginState
+
+
+def load_login_state(path: Path) -> LoginState:
+    """Load a previously stored :class:`LoginState` from ``path``."""
+
+    raw = path.read_text(encoding="utf-8")
+    data: Any
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:  # pragma: no cover - defensive guard
+        raise ValueError(f"Invalid JSON in {path}") from exc
+
+    return LoginState.model_validate(data)
+
+
+__all__ = ["load_login_state"]
+