lr-qrm 0.1.1__tar.gz → 0.1.3__tar.gz

{lr_qrm-0.1.1 → lr_qrm-0.1.3}/PKG-INFO

@@ -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.1 → lr_qrm-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-qrm"
-version = "0.1.1"
+version = "0.1.3"
 description = "CLI client for interacting with Qestit QRM data from LumenRadio tooling."
 readme = "src/README.md"
 requires-python = ">=3.9"

{lr_qrm-0.1.1 → lr_qrm-0.1.3}/src/README.md

@@ -43,10 +43,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
 
@@ -64,12 +72,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.1 → lr_qrm-0.1.3}/src/lr_qrm.egg-info/PKG-INFO

@@ -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.1 → lr_qrm-0.1.3}/src/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 "-"

lr_qrm-0.1.3/src/qrm/client.py

@@ -0,0 +1,366 @@
+"""HTTP client helpers for QRM services."""
+
+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
+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
+    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("/")
+        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)
+        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(
+                url,
+                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 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")
+        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
+        url = self._build_url("/Result/Status")
+        self._debug_request(
+            method="GET",
+            url=url,
+            headers=headers,
+            payload=None,
+        )
+        try:
+            response = self.session.get(
+                url,
+                headers=headers,
+                timeout=self.timeout,
+            )
+            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:
+            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
+
+        url = self._build_url("/Uut/Status")
+        self._debug_request(
+            method="POST",
+            url=url,
+            headers=headers,
+            payload=payload,
+        )
+        try:
+            response = self.session.post(
+                url,
+                headers=headers,
+                json=payload,
+                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 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("/"))
+
+    @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
+
+    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 → lr_qrm-0.1.3}/tests/test_cli.py

@@ -238,8 +238,8 @@ def test_uut_status_command_calls_client(monkeypatch, tmp_path: Path) -> None:
         "verify_tls": True,
         "token": "TOKEN123",
         "serial_number": "326115020010F2F1",
-        "start": "2026-02-01 00:00:00",
-        "stop": "2026-02-06 23:59:00",
+        "start": "2026-02-01T00:00:00Z",
+        "stop": "2026-02-06T23:59:00Z",
         "max_results": 50,
     }
 
@@ -285,7 +285,7 @@ def test_uut_status_command_supports_json_output(monkeypatch, tmp_path: Path) ->
 
 
 def test_uut_status_defaults_time_window(monkeypatch, tmp_path: Path) -> None:
-    """Start/stop defaults should cover the last 24 hours ending now."""
+    """Start defaults to the epoch while stop defaults to the provided value."""
 
     state = LoginState(  # type: ignore[call-arg]
         token="TOKEN123",
@@ -296,8 +296,8 @@ def test_uut_status_defaults_time_window(monkeypatch, tmp_path: Path) -> None:
     config_path = tmp_path / "login.json"
     config_path.write_text(state.model_dump_json())
 
-    fake_start = datetime(2026, 2, 5, 0, 0, tzinfo=timezone.utc)
-    fake_stop = datetime(2026, 2, 6, 0, 0, tzinfo=timezone.utc)
+    fake_start = datetime(1970, 1, 1, 0, 0, tzinfo=timezone.utc)
+    fake_stop = None
 
     def fake_resolver(start, stop):  # noqa: ANN001
         assert start is None and stop is None
@@ -331,11 +331,22 @@ def test_uut_status_defaults_time_window(monkeypatch, tmp_path: Path) -> None:
 
     assert result.exit_code == 0
     assert captured == {
-        "start": "2026-02-05 00:00:00",
-        "stop": "2026-02-06 00:00:00",
+        "start": "1970-01-01T00:00:00Z",
+        "stop": None,
     }
 
 
+def test_resolve_uut_window_defaults_epoch() -> None:
+    """When only stop is provided, start should fall back to the epoch."""
+
+    stop = datetime(2026, 2, 6, 0, 0, tzinfo=timezone.utc)
+
+    start, resolved_stop = cli._resolve_uut_window(None, stop)
+
+    assert start == datetime(1970, 1, 1, 0, 0, tzinfo=timezone.utc)
+    assert resolved_stop == stop
+
+
 def test_uut_status_handles_empty_payload(monkeypatch, tmp_path: Path) -> None:
     """An empty list should render the placeholder row."""
 
@@ -420,6 +431,252 @@ def test_uut_status_handles_irregular_rows(monkeypatch, tmp_path: Path) -> None:
     assert "12345" in result.stdout
 
 
+def test_box_list_command_calls_client(monkeypatch, tmp_path: Path) -> None:
+    """The box list subcommand should call its API helper."""
+
+    state = LoginState(  # type: ignore[call-arg]
+        token="TOKEN123",
+        username="alice",
+        base_url="https://qrm.local/api",
+        verify_tls=True,
+    )
+    config_path = tmp_path / "login.json"
+    config_path.write_text(state.model_dump_json())
+
+    captured = {}
+
+    class FakeClient:
+        def __init__(self, base_url: str, verify_tls: bool) -> None:  # noqa: D401
+            captured["base_url"] = base_url
+            captured["verify_tls"] = verify_tls
+
+        def box_list(
+            self,
+            *,
+            token: str,
+            start_datetime: str | None,
+            stop_datetime: str | None,
+        ):
+            captured["token"] = token
+            captured["start"] = start_datetime
+            captured["stop"] = stop_datetime
+            return [
+                {
+                    "BoxId": "BOX-1",
+                    "BoxName": "Fixture A",
+                    "Status": "Active",
+                    "StartDateTime": "2026-02-01T00:00:00Z",
+                    "StopDateTime": "2026-02-02T00:00:00Z",
+                    "Location": "OrbitOne",
+                }
+            ]
+
+    monkeypatch.setattr(cli, "QrmClient", FakeClient)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "box",
+            "list",
+            "--start",
+            "2026-02-01 00:00:00",
+            "--stop",
+            "2026-02-06 23:59:00",
+            "--config-path",
+            str(config_path),
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert "Fixture A" in result.stdout
+    assert captured == {
+        "base_url": "https://qrm.local/api",
+        "verify_tls": True,
+        "token": "TOKEN123",
+        "start": "2026-02-01T00:00:00Z",
+        "stop": "2026-02-06T23:59:00Z",
+    }
+
+
+def test_box_list_command_supports_json_output(monkeypatch, tmp_path: Path) -> None:
+    """Box list should honor --output json."""
+
+    state = LoginState(  # type: ignore[call-arg]
+        token="TOKEN123",
+        username="alice",
+        base_url="https://qrm.local/api",
+        verify_tls=True,
+    )
+    config_path = tmp_path / "login.json"
+    config_path.write_text(state.model_dump_json())
+
+    class FakeClient:
+        def __init__(self, *_: str, **__: str) -> None:  # noqa: D401, ANN001, ANN002, ANN003
+            pass
+
+        def box_list(self, **__: str):  # noqa: ANN003
+            return [{"BoxId": "BOX-1"}]
+
+    monkeypatch.setattr(cli, "QrmClient", FakeClient)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "box",
+            "list",
+            "--config-path",
+            str(config_path),
+            "--output",
+            "json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert json.loads(result.stdout) == [{"BoxId": "BOX-1"}]
+
+
+def test_box_list_defaults_time_window(monkeypatch, tmp_path: Path) -> None:
+    """Box list should default start to the epoch."""
+
+    state = LoginState(  # type: ignore[call-arg]
+        token="TOKEN123",
+        username="alice",
+        base_url="https://qrm.local/api",
+        verify_tls=True,
+    )
+    config_path = tmp_path / "login.json"
+    config_path.write_text(state.model_dump_json())
+
+    fake_start = datetime(1970, 1, 1, 0, 0, tzinfo=timezone.utc)
+    fake_stop = None
+
+    def fake_resolver(start, stop):  # noqa: ANN001
+        assert start is None and stop is None
+        return fake_start, fake_stop
+
+    monkeypatch.setattr(cli, "_resolve_box_window", fake_resolver)
+
+    captured = {}
+
+    class FakeClient:
+        def __init__(self, *_: str, **__: str) -> None:  # noqa: D401, ANN001, ANN002, ANN003
+            pass
+
+        def box_list(self, **kwargs):  # noqa: ANN003
+            captured["start"] = kwargs["start_datetime"]
+            captured["stop"] = kwargs["stop_datetime"]
+            return []
+
+    monkeypatch.setattr(cli, "QrmClient", FakeClient)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "box",
+            "list",
+            "--config-path",
+            str(config_path),
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert captured == {
+        "start": "1970-01-01T00:00:00Z",
+        "stop": None,
+    }
+
+
+def test_resolve_box_window_defaults_epoch() -> None:
+    """Helper should mirror the epoch default behavior."""
+
+    stop = datetime(2026, 2, 6, 0, 0, tzinfo=timezone.utc)
+
+    start, resolved_stop = cli._resolve_box_window(None, stop)
+
+    assert start == datetime(1970, 1, 1, 0, 0, tzinfo=timezone.utc)
+    assert resolved_stop == stop
+
+
+def test_box_list_handles_empty_payload(monkeypatch, tmp_path: Path) -> None:
+    """Empty responses should render a helpful message."""
+
+    state = LoginState(  # type: ignore[call-arg]
+        token="TOKEN123",
+        username="alice",
+        base_url="https://qrm.local/api",
+        verify_tls=True,
+    )
+    config_path = tmp_path / "login.json"
+    config_path.write_text(state.model_dump_json())
+
+    class FakeClient:
+        def __init__(self, *_: str, **__: str) -> None:  # noqa: D401, ANN001, ANN002, ANN003
+            pass
+
+        def box_list(self, **__: str):  # noqa: ANN003
+            return []
+
+    monkeypatch.setattr(cli, "QrmClient", FakeClient)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "box",
+            "list",
+            "--config-path",
+            str(config_path),
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert "No results" in result.stdout
+
+
+def test_box_list_handles_irregular_rows(monkeypatch, tmp_path: Path) -> None:
+    """Irregular list entries should still render."""
+
+    state = LoginState(  # type: ignore[call-arg]
+        token="TOKEN123",
+        username="alice",
+        base_url="https://qrm.local/api",
+        verify_tls=True,
+    )
+    config_path = tmp_path / "login.json"
+    config_path.write_text(state.model_dump_json())
+
+    class FakeClient:
+        def __init__(self, *_: str, **__: str) -> None:  # noqa: D401, ANN001, ANN002, ANN003
+            pass
+
+        def box_list(self, **__: str):  # noqa: ANN003
+            return [
+                {
+                    "Id": "BOX-1",
+                    "Location": "OrbitOne",
+                    "StartDateTime": datetime(2026, 2, 1, 12, 0, tzinfo=timezone.utc),
+                    "StopDateTime": None,
+                    "Status": "Active",
+                },
+                123,
+            ]
+
+    monkeypatch.setattr(cli, "QrmClient", FakeClient)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "box",
+            "list",
+            "--config-path",
+            str(config_path),
+        ],
+    )
+
+    assert result.exit_code == 0
+    assert "BOX-1" in result.stdout
+    assert "123" in result.stdout
+
+
 def test_cli_displays_help_when_no_command() -> None:
     """Invoking the CLI without arguments returns the Typer help text."""
 

{lr_qrm-0.1.1 → lr_qrm-0.1.3}/tests/test_client.py

@@ -19,6 +19,7 @@ class FakeResponse:
         text_data: str | None = None,
         status_code: int = 200,
         json_error: bool = False,
+        headers: dict | None = None,
     ) -> None:
         self._json_data = json_data
         self._json_error = json_error
@@ -26,6 +27,7 @@ class FakeResponse:
             text_data = json.dumps(json_data)
         self._text_data = text_data or ""
         self.status_code = status_code
+        self.headers = headers or {}
 
     def json(self) -> object:
         if self._json_error:
@@ -143,6 +145,17 @@ def test_status_returns_plain_text_when_json_invalid() -> None:
     assert session.get_kwargs["headers"] is None
 
 
+def test_status_prompts_relogin_on_401() -> None:
+    response = FakeResponse(status_code=401)
+    session = FakeSession(response)
+    client = QrmClient(base_url="https://qrm.example.com/api", session=session)
+
+    with pytest.raises(QrmClientError) as excinfo:
+        client.status(token="TOKEN123")
+
+    assert "qrm login" in str(excinfo.value)
+
+
 def test_client_requires_base_url() -> None:
     with pytest.raises(ValueError):
         QrmClient(base_url="")
@@ -213,3 +226,51 @@ def test_client_disables_warnings_when_insecure(monkeypatch) -> None:
 
     assert client.session.verify is False
     assert captured["warning"] is client_module.urllib3.exceptions.InsecureRequestWarning
+
+
+def test_box_list_posts_filters() -> None:
+    response = FakeResponse(json_data=[{"BoxId": 1}])
+    session = FakeSession(response)
+    client = QrmClient(base_url="https://qrm.example.com/api", session=session)
+
+    payload = client.box_list(
+        token="TOKEN123",
+        start_datetime="1970-01-01 00:00:00",
+        stop_datetime="2026-02-06 00:00:00",
+    )
+
+    assert payload == [{"BoxId": 1}]
+    assert session.post_kwargs == {
+        "url": "https://qrm.example.com/api/Box/List",
+        "json": {
+            "startDateTime": "1970-01-01 00:00:00",
+            "stopDateTime": "2026-02-06 00:00:00",
+        },
+        "timeout": 10.0,
+        "headers": {"Authorization": "Bearer TOKEN123"},
+    }
+
+
+def test_box_list_requires_token() -> None:
+    client = QrmClient(
+        base_url="https://qrm.example.com/api",
+        session=FakeSession(FakeResponse(json_data=[])),
+    )
+
+    with pytest.raises(ValueError):
+        client.box_list(token="")
+
+
+def test_debug_logging_captures_request_and_response(monkeypatch, capsys) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setenv("QRM_DEBUG", "1")
+    response = FakeResponse(json_data={"healthy": True}, headers={"X-Test": "1"})
+    session = FakeSession(response)
+    client = QrmClient(base_url="https://qrm.example.com/api", session=session)
+
+    client.status(token="TOKEN123")
+
+    stderr = capsys.readouterr().err
+    assert "[QRM DEBUG] REQUEST" in stderr
+    assert "[QRM DEBUG] RESPONSE" in stderr
+    assert "/Result/Status" in stderr
+    assert "\"healthy\"" in stderr

lr_qrm-0.1.1/src/qrm/client.py

@@ -1,183 +0,0 @@
-"""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"]