lr-qrm 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

{lr_qrm-0.1.1.dist-info → lr_qrm-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-qrm
-Version: 0.1.1
+Version: 0.1.3
 Summary: CLI client for interacting with Qestit QRM data from LumenRadio tooling.
 Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
 License: MIT License
@@ -66,10 +66,18 @@ qrm status
 #### Inspect UUT history
 
 ```bash
-qrm uut status 326115020010F2F1 --start "2026-02-01 00:00:00" --stop "2026-02-06 23:59:00"
+qrm uut status 326115020010F2F1 --start "2026-02-01T00:00:00Z" --stop "2026-02-06T23:59:00Z"
 ```
 
-By default the command queries the last 24 hours ending now. Pass `--base-url` and `--insecure` to override the stored settings when needed.
+By default the command uses `1970-01-01T00:00:00Z` as the start timestamp and lets QRM treat the stop as "now" (omit `--stop`). Pass `--base-url` and `--insecure` to override the stored settings when needed.
+
+#### List production boxes
+
+```bash
+qrm box list --stop "2026-02-06T23:59:00Z"
+```
+
+If you omit `--start`, the command defaults to the Unix epoch (`1970-01-01T00:00:00Z`). Leave `--stop` out to let QRM use its current time.
 
 #### JSON output
 
@@ -87,12 +95,19 @@ from qrm.client import QrmClient
 
 state = load_login_state()
 client = QrmClient(base_url=str(state.base_url), verify_tls=state.verify_tls)
+
 uut_runs = client.uut_status(
-  token=state.token,
-  serial_number="326115020010F2F1",
-  start_datetime="2026-02-01 00:00:00",
-  stop_datetime="2026-02-06 23:59:00",
-  max_results=1000,
+    token=state.token,
+    serial_number="326115020010F2F1",
+    start_datetime="2026-02-01T00:00:00Z",
+    stop_datetime="2026-02-06T23:59:00Z",
+    max_results=1000,
+)
+
+boxes = client.box_list(
+    token=state.token,
+    start_datetime="1970-01-01T00:00:00Z",
+    stop_datetime="2026-02-06T23:59:00Z",
 )
 ```
 

lr_qrm-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+lr_qrm-0.1.3.dist-info/licenses/LICENSE,sha256=cEnG3HeMPa3GKtuENkytOQaNJS9rwMMU_KWHObdWbOY,1070
+qrm/__init__.py,sha256=vpsqqB9AKEhCcTdlSNeMF74vKSUG2NuUPEd5uE6u-ws,1069
+qrm/cli.py,sha256=djqm4xNwPKk82mZPXHsuELe7gQDRzLvEePHh83L2GUs,14716
+qrm/client.py,sha256=8i2IJx1D8S2g1BBReH_7rr0Lq4YKbpKtuVljm_4rqig,11431
+qrm/config.py,sha256=TewatdLxqbCa7hBLbqj8hrKbposvbD-Wc1TSiUipzq4,623
+lr_qrm-0.1.3.dist-info/METADATA,sha256=8jM8UVe4lYKuxsBV6Z1WHu-iNKRvoNOXk57gU2IALYk,2753
+lr_qrm-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lr_qrm-0.1.3.dist-info/entry_points.txt,sha256=9CaqYoIqOC9O40WoJ6SM1qYk9gP5VVShmMc51zBqas4,36
+lr_qrm-0.1.3.dist-info/top_level.txt,sha256=URCUvNbN-7KWypbbmrCaie8JjKDowz0p4GNhBqnN99U,4
+lr_qrm-0.1.3.dist-info/RECORD,,

qrm/cli.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any
@@ -28,15 +28,18 @@ class OutputFormat(str, Enum):
 app = typer.Typer(help="Interact with the Qestit QRM service.")
 console = Console()
 uut_app = typer.Typer(help="Inspect Units Under Test (UUTs).")
+box_app = typer.Typer(help="Inspect production boxes.")
 app.add_typer(uut_app, name="uut")
+app.add_typer(box_app, name="box")
 
-UUT_API_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
-UUT_CLI_DATE_FORMATS = [
-    UUT_API_DATE_FORMAT,
+API_DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+CLI_DATE_FORMATS = [
+    API_DATE_FORMAT,
+    "%Y-%m-%d %H:%M:%S",
     "%Y-%m-%dT%H:%M:%S",
     "%Y-%m-%dT%H:%M:%S%z",
 ]
-UUT_DEFAULT_WINDOW = timedelta(days=1)
+EPOCH_START = datetime(1970, 1, 1, tzinfo=timezone.utc)
 
 
 @app.callback(invoke_without_command=True)
@@ -166,14 +169,20 @@ def uut_status(
     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.",
+        formats=CLI_DATE_FORMATS,
+        help=(
+            "Filter from this timestamp (UTC). Accepts ISO-8601 (e.g. 2020-01-01T00:00:00Z) "
+            "or YYYY-MM-DD HH:MM:SS. Default: 1970-01-01T00:00:00Z."
+        ),
     ),
     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.",
+        formats=CLI_DATE_FORMATS,
+        help=(
+            "Filter until this timestamp (UTC). Accepts ISO-8601 (e.g. 2026-02-06T23:59:00Z) "
+            "or YYYY-MM-DD HH:MM:SS. Default: QRM current time."
+        ),
     ),
     max_results: int = typer.Option(
         1000,
@@ -209,7 +218,7 @@ def uut_status(
     """Fetch UUT execution history using the `/Uut/Status` endpoint."""
 
     state = _load_state_or_exit(config_path)
-    start, stop = _resolve_uut_window(start, stop)
+    resolved_start, resolved_stop = _resolve_uut_window(start, stop)
 
     client = QrmClient(
         base_url=base_url or str(state.base_url),
@@ -220,8 +229,8 @@ def uut_status(
         payload = client.uut_status(
             token=state.token,
             serial_number=serial_number,
-            start_datetime=_format_uut_datetime(start),
-            stop_datetime=_format_uut_datetime(stop),
+            start_datetime=_format_api_datetime(resolved_start),
+            stop_datetime=_format_api_datetime(resolved_stop) if resolved_stop is not None else None,
             max_results=max_results,
         )
     except QrmClientError as exc:
@@ -235,6 +244,76 @@ def uut_status(
     console.print(_render_uut_status(payload))
 
 
+@box_app.command("list")
+def box_list(
+    start: datetime | None = typer.Option(
+        None,
+        "--start",
+        formats=CLI_DATE_FORMATS,
+        help=(
+            "Filter from this timestamp (UTC). Accepts ISO-8601 (e.g. 2020-01-01T00:00:00Z) "
+            "or YYYY-MM-DD HH:MM:SS. Default: 1970-01-01T00:00:00Z."
+        ),
+    ),
+    stop: datetime | None = typer.Option(
+        None,
+        "--stop",
+        formats=CLI_DATE_FORMATS,
+        help=(
+            "Filter until this timestamp (UTC). Accepts ISO-8601 (e.g. 2026-02-06T23:59:00Z) "
+            "or YYYY-MM-DD HH:MM:SS. Default: QRM current time."
+        ),
+    ),
+    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:
+    """List production boxes via the `/Box/List` endpoint."""
+
+    state = _load_state_or_exit(config_path)
+    resolved_start, resolved_stop = _resolve_box_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.box_list(
+            token=state.token,
+            start_datetime=_format_api_datetime(resolved_start),
+            stop_datetime=_format_api_datetime(resolved_stop) if resolved_stop is not None else None,
+        )
+    except QrmClientError as exc:
+        typer.secho(f"Box list 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_box_list(payload))
+
+
 def _resolve_config_path(config_path: Path | None) -> Path:
     return config_path.expanduser() if config_path else DEFAULT_CONFIG_PATH
 
@@ -278,17 +357,35 @@ 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 _resolve_window(start, stop, default_start=EPOCH_START)
+
+
+def _resolve_box_window(
+    start: datetime | None,
+    stop: datetime | None,
+) -> tuple[datetime, datetime]:
+    return _resolve_window(start, stop, default_start=EPOCH_START)
+
+
+def _resolve_window(
+    start: datetime | None,
+    stop: datetime | None,
+    *,
+    default_start: datetime,
+) -> tuple[datetime, datetime | None]:
+    stop_value = stop
+    start_value = start or default_start
+    if stop_value and start_value > stop_value:
+        raise typer.BadParameter("--start must be earlier than --stop")
     return start_value, stop_value
 
 
-def _format_uut_datetime(value: datetime | None) -> str | None:
+def _format_api_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)
+        value = value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc).strftime(API_DATE_FORMAT)
 
 
 def _render_uut_status(payload: Any) -> Table:
@@ -326,6 +423,38 @@ def _render_uut_status(payload: Any) -> Table:
     return table
 
 
+def _render_box_list(payload: Any) -> Table:
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Box", style="cyan")
+    table.add_column("Name", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Start", style="magenta")
+    table.add_column("Stop", style="magenta")
+    table.add_column("Location", 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
+
+        table.add_row(
+            str(entry.get("BoxId") or entry.get("Id", "-")),
+            str(entry.get("BoxName") or entry.get("Name", "-")),
+            str(entry.get("Status") or entry.get("Outcome", "-")),
+            _format_timestamp(entry.get("StartDateTime")),
+            _format_timestamp(entry.get("StopDateTime")),
+            str(entry.get("Location") or entry.get("StationName") 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 "-"

qrm/client.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import json
+import os
+import pprint
+import sys
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
@@ -42,8 +45,10 @@ class QrmClient:
     verify_tls: bool = True
     timeout: float = 10.0
     session: Optional[requests.Session] = None
+    debug: bool = False
 
     def __post_init__(self) -> None:
+        self.debug = self.debug or os.getenv("QRM_DEBUG") == "1"
         if not self.base_url:
             raise ValueError("base_url must be provided")
         self.base_url = self.base_url.rstrip("/")
@@ -56,16 +61,32 @@ class QrmClient:
         """Authenticate against `/User/Login` and return the bearer token."""
 
         credentials = LoginCredentials(username=username, password=password)
+        url = self._build_url("/User/Login")
+        body = credentials.model_dump()
+        self._debug_request(
+            method="POST",
+            url=url,
+            headers=None,
+            payload=body,
+        )
         try:
             response = self.session.post(
-                self._build_url("/User/Login"),
-                json=credentials.model_dump(),
+                url,
+                json=body,
                 timeout=self.timeout,
             )
-            response.raise_for_status()
+            self._debug_response(method="POST", url=url, response=response)
         except requests.RequestException as exc:  # pragma: no cover - network failure
+            self._debug_error(method="POST", url=url, error=exc)
             raise QrmClientError("Failed to contact QRM login endpoint") from exc
 
+        self._ensure_success(
+            response=response,
+            method="POST",
+            url=url,
+            error_message="Failed to contact QRM login endpoint",
+        )
+
         token = self._extract_token(response)
         if not token:
             raise QrmClientError("QRM login response did not contain a token")
@@ -75,16 +96,31 @@ class QrmClient:
         """Query the `/Result/Status` endpoint to verify service health."""
 
         headers = {"Authorization": f"Bearer {token}"} if token else None
+        url = self._build_url("/Result/Status")
+        self._debug_request(
+            method="GET",
+            url=url,
+            headers=headers,
+            payload=None,
+        )
         try:
             response = self.session.get(
-                self._build_url("/Result/Status"),
+                url,
                 headers=headers,
                 timeout=self.timeout,
             )
-            response.raise_for_status()
+            self._debug_response(method="GET", url=url, response=response)
         except requests.RequestException as exc:  # pragma: no cover - network failure
+            self._debug_error(method="GET", url=url, error=exc)
             raise QrmClientError("Failed to contact QRM status endpoint") from exc
 
+        self._ensure_success(
+            response=response,
+            method="GET",
+            url=url,
+            error_message="Failed to contact QRM status endpoint",
+        )
+
         try:
             return response.json()
         except ValueError:
@@ -114,22 +150,114 @@ class QrmClient:
         if max_results is not None:
             payload["maxNumberOfResults"] = max_results
 
+        url = self._build_url("/Uut/Status")
+        self._debug_request(
+            method="POST",
+            url=url,
+            headers=headers,
+            payload=payload,
+        )
         try:
             response = self.session.post(
-                self._build_url("/Uut/Status"),
+                url,
                 headers=headers,
                 json=payload,
                 timeout=self.timeout,
             )
-            response.raise_for_status()
+            self._debug_response(method="POST", url=url, response=response)
         except requests.RequestException as exc:  # pragma: no cover - network failure
+            self._debug_error(method="POST", url=url, error=exc)
             raise QrmClientError("Failed to contact QRM UUT status endpoint") from exc
 
+        self._ensure_success(
+            response=response,
+            method="POST",
+            url=url,
+            error_message="Failed to contact QRM UUT status endpoint",
+        )
+
+        try:
+            return response.json()
+        except ValueError:
+            return response.text.strip()
+
+    def box_list(
+        self,
+        *,
+        token: str,
+        start_datetime: Optional[str] = None,
+        stop_datetime: Optional[str] = None,
+    ) -> Any:
+        """Query the `/Box/List` endpoint for production boxes."""
+
+        if not token:
+            raise ValueError("token must be provided")
+
+        headers = {"Authorization": f"Bearer {token}"}
+        payload: Dict[str, Any] = {}
+        if start_datetime:
+            payload["startDateTime"] = start_datetime
+        if stop_datetime:
+            payload["stopDateTime"] = stop_datetime
+
+        body = payload or None
+        url = self._build_url("/Box/List")
+        self._debug_request(
+            method="POST",
+            url=url,
+            headers=headers,
+            payload=body,
+        )
+        try:
+            response = self.session.post(
+                url,
+                headers=headers,
+                json=body,
+                timeout=self.timeout,
+            )
+            self._debug_response(method="POST", url=url, response=response)
+        except requests.RequestException as exc:  # pragma: no cover - network failure
+            self._debug_error(method="POST", url=url, error=exc)
+            raise QrmClientError("Failed to contact QRM box list endpoint") from exc
+
+        self._ensure_success(
+            response=response,
+            method="POST",
+            url=url,
+            error_message="Failed to contact QRM box list endpoint",
+        )
+
         try:
             return response.json()
         except ValueError:
             return response.text.strip()
 
+    def _ensure_success(
+        self,
+        *,
+        response: requests.Response,
+        method: str,
+        url: str,
+        error_message: str,
+    ) -> None:
+        if response.status_code == 401:
+            message = (
+                "Authentication failed (HTTP 401). Your credentials may be invalid or expired. "
+                "Please run `qrm login` and try again."
+            )
+            self._debug_error(
+                method=method,
+                url=url,
+                error=RuntimeError(message),
+            )
+            raise QrmClientError(message)
+
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            self._debug_error(method=method, url=url, error=exc)
+            raise QrmClientError(error_message) from exc
+
     def _build_url(self, path: str) -> str:
         return urljoin(f"{self.base_url}/", path.lstrip("/"))
 
@@ -179,5 +307,60 @@ class QrmClient:
             return trimmed
         return None
 
+    def _debug_request(
+        self,
+        *,
+        method: str,
+        url: str,
+        headers: Optional[Dict[str, Any]],
+        payload: Any,
+    ) -> None:
+        if not self.debug:
+            return
+        data: Dict[str, Any] = {"method": method, "url": url}
+        if headers is not None:
+            data["headers"] = headers
+        if payload is not None:
+            data["body"] = payload
+        self._debug_http("REQUEST", data)
+
+    def _debug_response(
+        self,
+        *,
+        method: str,
+        url: str,
+        response: requests.Response,
+    ) -> None:
+        if not self.debug:
+            return
+        headers = getattr(response, "headers", None)
+        data: Dict[str, Any] = {
+            "method": method,
+            "url": url,
+            "status_code": response.status_code,
+            "body": response.text,
+        }
+        if headers is not None:
+            data["headers"] = dict(headers)
+        self._debug_http("RESPONSE", data)
+
+    def _debug_error(self, *, method: str, url: str, error: Exception) -> None:
+        if not self.debug:
+            return
+        self._debug_http(
+            "ERROR",
+            {
+                "method": method,
+                "url": url,
+                "error": f"{error.__class__.__name__}: {error}",
+            },
+        )
+
+    def _debug_http(self, stage: str, payload: Dict[str, Any]) -> None:
+        if not self.debug:
+            return
+        formatted = pprint.pformat(payload)
+        print(f"[QRM DEBUG] {stage}: {formatted}", file=sys.stderr)
+
 
 __all__ = ["LoginCredentials", "LoginState", "QrmClient", "QrmClientError"]

lr_qrm-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-lr_qrm-0.1.1.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.1.dist-info/METADATA,sha256=DaUZm9XUDnxxWReoj9GzpoUcxxYDY-1Zrbln0bGc1xQ,2310
-lr_qrm-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-lr_qrm-0.1.1.dist-info/entry_points.txt,sha256=9CaqYoIqOC9O40WoJ6SM1qYk9gP5VVShmMc51zBqas4,36
-lr_qrm-0.1.1.dist-info/top_level.txt,sha256=URCUvNbN-7KWypbbmrCaie8JjKDowz0p4GNhBqnN99U,4
-lr_qrm-0.1.1.dist-info/RECORD,,