lr-gladiator 0.12.0__py3-none-any.whl

gladiator/checksums.py

@@ -0,0 +1,31 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# src/gladiator/checksums.py
+from __future__ import annotations
+from pathlib import Path
+import hashlib
+import base64
+
+
+def sha256_file(path: Path, chunk_size: int = 128 * 1024) -> str:
+    """
+    Return the lowercase hex SHA-256 of the file at `path`.
+    Streams the file in chunks to support large files.
+    """
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(chunk_size), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def md5_base64_file(path: Path, chunk_size: int = 128 * 1024) -> str:
+    """
+    Return base64-encoded MD5 digest of the file at `path`,
+    suitable for the Content-MD5 header per RFC 1864.
+    """
+    h = hashlib.md5()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(chunk_size), b""):
+            h.update(chunk)
+    return base64.b64encode(h.digest()).decode("ascii")

gladiator/cli.py

@@ -0,0 +1,433 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# src/gladiator/cli.py
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import Optional
+import typer
+from rich import print
+from rich.table import Table
+from rich.console import Console
+from rich.status import Status
+from getpass import getpass
+import requests
+import sys
+import os
+from urllib.parse import urlparse
+from .config import LoginConfig, save_config, load_config, save_config_raw, CONFIG_PATH
+from .arena import ArenaClient, ArenaError
+
+app = typer.Typer(add_completion=False, help="Arena PLM command-line utility")
+console = Console()
+
+# --- tiny helper to show a spinner when appropriate ---
+from contextlib import contextmanager
+
+
+@contextmanager
+def spinner(message: str, enabled: bool = True):
+    """
+    Show a Rich spinner while the body executes.
+    Auto-disables if stdout is not a TTY (e.g., CI) or enabled=False.
+    """
+    if enabled and sys.stdout.isatty():
+        with console.status(message, spinner="dots"):
+            yield
+    else:
+        yield
+
+
+@app.command()
+def login(
+    username: Optional[str] = typer.Option(
+        None, "--username", envvar="GLADIATOR_USERNAME"
+    ),
+    password: Optional[str] = typer.Option(
+        None, "--password", envvar="GLADIATOR_PASSWORD"
+    ),
+    base_url: Optional[str] = typer.Option(
+        "https://api.arenasolutions.com/v1", help="Arena API base URL"
+    ),
+    verify_tls: bool = typer.Option(True, help="Verify TLS certificates"),
+    non_interactive: bool = typer.Option(
+        False, "--ci", help="Fail instead of prompting for missing values"
+    ),
+    reason: Optional[str] = typer.Option(
+        "CI/CD integration", help="Arena-Usage-Reason header"
+    ),
+):
+    """Create or update ~/.config/gladiator/login.json for subsequent commands."""
+    if not username and not non_interactive:
+        username = typer.prompt("Email/username")
+    if not password and not non_interactive:
+        password = getpass("Password: ")
+    if non_interactive and (not username or not password):
+        raise typer.BadParameter(
+            "Provide --username and --password (or set env vars) for --ci mode"
+        )
+
+    # Perform login
+    sess = requests.Session()
+    sess.verify = verify_tls
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Arena-Usage-Reason": reason or "gladiator/cli",
+        "User-Agent": "gladiator-arena/0.1",
+    }
+    url = f"{(base_url or '').rstrip('/')}/login"
+    try:
+        with spinner("Logging in…", enabled=sys.stdout.isatty()):
+            resp = sess.post(
+                url, headers=headers, json={"email": username, "password": password}
+            )
+            resp.raise_for_status()
+    except Exception as e:
+        typer.secho(
+            f"Login failed: {e} Body: {getattr(resp, 'text', '')[:400]}",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(2)
+
+    data = resp.json()
+    data.update({"base_url": base_url, "verify_tls": verify_tls, "reason": reason})
+    save_config_raw(data)
+    print(f"[green]Saved session to {CONFIG_PATH}[/green]")
+
+
+def _client() -> ArenaClient:
+    cfg = load_config()
+    return ArenaClient(cfg)
+
+
+@app.command("latest-approved")
+def latest_approved(
+    item: str = typer.Argument(..., help="Item/article number"),
+    format: Optional[str] = typer.Option(
+        None, "--format", "-f", help="Output format: human (default) or json"
+    ),
+):
+    """Print latest approved revision for the given item number."""
+    json_mode = (format or "").lower() == "json"
+    try:
+        with spinner(
+            f"Resolving latest approved revision for {item}…", enabled=not json_mode
+        ):
+            rev = _client().get_latest_approved_revision(item)
+        if json_mode:
+            json.dump({"article": item, "revision": rev}, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            print(rev)
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+@app.command("list-files")
+def list_files(
+    item: str = typer.Argument(..., help="Item/article number"),
+    revision: Optional[str] = typer.Option(
+        None,
+        "--rev",
+        help="Revision selector: WORKING | EFFECTIVE | <label> (default: EFFECTIVE)",
+    ),
+    format: Optional[str] = typer.Option(
+        None, "--format", "-f", help="Output format: human (default) or json"
+    ),
+):
+    json_mode = (format or "").lower() == "json"
+    try:
+        with spinner(
+            f"Listing files for {item} ({revision or 'EFFECTIVE'})…",
+            enabled=not json_mode,
+        ):
+            files = _client().list_files(item, revision)
+
+        if json_mode:
+            json.dump(
+                {"article": item, "revision": revision, "files": files},
+                sys.stdout,
+                indent=2,
+            )
+            sys.stdout.write("\n")
+            return
+
+        table = Table(title=f"Files for {item} rev {revision or '(latest approved)'}")
+        table.add_column("Title")
+        table.add_column("Filename")
+        table.add_column("Size", justify="right")
+        table.add_column("Edition")
+        table.add_column("Type")
+        table.add_column("Location")
+        for f in files:
+            table.add_row(
+                str(f.get("title")),
+                str(f.get("name")),
+                str(f.get("size")),
+                str(f.get("edition")),
+                str(f.get("storageMethodName") or ""),
+                str(f.get("location") or ""),
+            )
+        print(table)
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+@app.command("bom")
+def bom(
+    item: str = typer.Argument(..., help="Item/article number (e.g., 890-1001)"),
+    revision: Optional[str] = typer.Option(
+        None,
+        "--rev",
+        help='Revision selector: WORKING, EFFECTIVE (default), or label (e.g., "B2")',
+    ),
+    output: str = typer.Option(
+        "table", "--output", help='Output format: "table" (default) or "json"'
+    ),
+    recursive: bool = typer.Option(
+        False, "--recursive/--no-recursive", help="Recursively expand subassemblies"
+    ),
+    max_depth: Optional[int] = typer.Option(
+        None,
+        "--max-depth",
+        min=1,
+        help="Maximum recursion depth (1 = only children). Omit for unlimited.",
+    ),
+):
+    """List the BOM lines for an item revision."""
+    json_mode = output.lower() == "json"
+    try:
+        with spinner(
+            f"Fetching BOM for {item} ({revision or 'EFFECTIVE'})"
+            + (" [recursive]" if recursive else "")
+            + "…",
+            enabled=not json_mode,
+        ):
+            lines = _client().get_bom(
+                item, revision, recursive=recursive, max_depth=max_depth
+            )
+
+        if json_mode:
+            print(json.dumps({"count": len(lines), "results": lines}, indent=2))
+            return
+
+        title_rev = revision or "(latest approved)"
+        table = Table(title=f"BOM for {item} rev {title_rev}")
+        table.add_column("Line", justify="right")
+        table.add_column("Qty", justify="right")
+        table.add_column("Number")
+        table.add_column("Name")
+        table.add_column("RefDes")
+
+        for ln in lines:
+            lvl = int(ln.get("level", 0) or 0)
+            indent = "  " * lvl
+            table.add_row(
+                str(ln.get("lineNumber") or ""),
+                str(ln.get("quantity") or ""),
+                str(ln.get("itemNumber") or ""),
+                f"{indent}{str(ln.get('itemName') or '')}",
+                str(ln.get("refDes") or ""),
+            )
+        print(table)
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+@app.command("get-files")
+def get_files(
+    item: str = typer.Argument(..., help="Item/article number"),
+    revision: Optional[str] = typer.Option(
+        None, "--rev", help="Revision (default: latest approved)"
+    ),
+    out: Optional[Path] = typer.Option(
+        None,
+        "--out",
+        help="Output directory (default: a folder named after the item number)",
+    ),
+    recursive: bool = typer.Option(
+        False,
+        "--recursive/--no-recursive",
+        help="Recursively download files from subassemblies",
+    ),
+    max_depth: Optional[int] = typer.Option(
+        None,
+        "--max-depth",
+        min=1,
+        help="Maximum recursion depth for --recursive (1 = only direct children).",
+    ),
+):
+    json_mode = False  # this command prints file paths line-by-line (no JSON mode here)
+    try:
+        out_dir = out or Path(item)
+        with spinner(
+            f"Downloading files for {item} ({revision or 'EFFECTIVE'})"
+            + (" [recursive]" if recursive else "")
+            + f" → {out_dir}…",
+            enabled=not json_mode,
+        ):
+            if recursive:
+                paths = _client().download_files_recursive(
+                    item, revision, out_dir=out_dir, max_depth=max_depth
+                )
+            else:
+                paths = _client().download_files(item, revision, out_dir=out_dir)
+
+        for p in paths:
+            print(str(p))
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+@app.command("upload-file")
+def upload_file(
+    item: str = typer.Argument(...),
+    file: Path = typer.Argument(...),
+    reference: Optional[str] = typer.Option(
+        None, "--reference", help="Optional reference string"
+    ),
+    title: Optional[str] = typer.Option(
+        None,
+        "--title",
+        help="Override file title (default: filename without extension)",
+    ),
+    category: str = typer.Option(
+        "Firmware", "--category", help='File category name (default: "Firmware")'
+    ),
+    file_format: Optional[str] = typer.Option(
+        None, "--format", help="File format (default: file extension)"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--desc", help="Optional description"
+    ),
+    primary: bool = typer.Option(
+        False, "--primary/--no-primary", help="Mark association as primary"
+    ),
+    edition: str = typer.Option(
+        None,
+        "--edition",
+        help="Edition number when creating a new association (default: SHA256 checksum of file)",
+    ),
+):
+    """
+    Create or update a file.
+    If a file with the same filename exists: update its content (new edition).
+    Otherwise: create a new association on the WORKING revision (requires --edition)."""
+    try:
+        with spinner(f"Uploading {file.name} to {item}…", enabled=sys.stdout.isatty()):
+            result = _client().upload_file_to_working(
+                item,
+                file,
+                reference,
+                title=title,
+                category_name=category,
+                file_format=file_format,
+                description=description,
+                primary=primary,
+                edition=edition,
+            )
+        print(json.dumps(result, indent=2))
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+@app.command("upload-weblink")
+def upload_weblink(
+    item: str = typer.Argument(..., help="Item/article number"),
+    url: str = typer.Argument(..., help="HTTP(S) URL to associate as a web link"),
+    reference: Optional[str] = typer.Option(
+        None, "--reference", help="Optional reference string on the association"
+    ),
+    title: Optional[str] = typer.Option(
+        None,
+        "--title",
+        help="File title (default: derived from URL hostname/path)",
+    ),
+    category: str = typer.Option(
+        "Source Code", "--category", help='File category name (default: "Source Code")'
+    ),
+    file_format: Optional[str] = typer.Option(
+        "url",
+        "--format",
+        help='File format/extension label (default: "url")',
+    ),
+    description: Optional[str] = typer.Option(
+        "None", "--description", help="Optional description"
+    ),
+    primary: bool = typer.Option(
+        False,
+        "--primary/--no-primary",
+        help="Mark association as primary (default: false)",
+    ),
+    edition: Optional[str] = typer.Option(
+        None,
+        "--edition",
+        help="Edition label (default: SHA256(url)[:16])",
+    ),
+    latest_edition_association: bool = typer.Option(
+        True,
+        "--latest/--no-latest",
+        help="Keep association pointed to the latest edition (default: true)",
+    ),
+):
+    """
+    Create or update a 'web link' file on the WORKING revision.
+    If a matching link (by URL or title) exists, its File is updated in-place.
+    Otherwise a new File is created and associated.
+    """
+    # Best-effort default title from URL if not provided
+    if not title:
+        try:
+            u = urlparse(url)
+            base = (u.netloc + u.path).rstrip("/") or u.netloc or url
+            title = base.split("/")[-1] or base
+        except Exception:
+            title = url
+
+    try:
+        with spinner(f"Uploading web-link to {item}…", enabled=sys.stdout.isatty()):
+            result = _client().upload_weblink_to_working(
+                item_number=item,
+                url=url,
+                reference=reference,
+                title=title,
+                category_name=category,
+                file_format=file_format,
+                description=description,
+                primary=primary,
+                latest_edition_association=latest_edition_association,
+                edition=edition,
+            )
+        print(json.dumps(result, indent=2))
+    except requests.HTTPError as e:
+        typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(2)
+
+
+if __name__ == "__main__":
+    app()

gladiator/config.py

@@ -0,0 +1,60 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# src/gladiator/config.py
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional, Any, Dict
+
+from pydantic import BaseModel, Field, ConfigDict
+
+CONFIG_HOME = Path(
+    os.environ.get("GLADIATOR_CONFIG_HOME", Path.home() / ".config" / "gladiator")
+)
+CONFIG_PATH = Path(os.environ.get("GLADIATOR_CONFIG", CONFIG_HOME / "login.json"))
+
+
+class LoginConfig(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    # Primary connection settings
+    base_url: str = Field(
+        "https://api.arenasolutions.com/v1", description="Arena REST API base URL"
+    )
+    verify_tls: bool = True
+
+    # Auth options
+    api_key: Optional[str] = None  # not used by Arena v1 but kept for future
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+    # Session from `/login`
+    arena_session_id: Optional[str] = Field(None, alias="arenaSessionId")
+    workspace_id: Optional[int] = Field(None, alias="workspaceId")
+    workspace_name: Optional[str] = Field(None, alias="workspaceName")
+    workspace_request_limit: Optional[int] = Field(None, alias="workspaceRequestLimit")
+    reason: Optional[str] = None
+
+
+def save_config_raw(data: Dict[str, Any], path: Path = CONFIG_PATH) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    try:
+        os.chmod(path, 0o600)
+    except PermissionError:
+        # Best-effort on non-POSIX filesystems
+        pass
+
+
+def save_config(cfg: LoginConfig, path: Path = CONFIG_PATH) -> None:
+    # Respect the provided path (bug fix); keep aliases for compatibility with bash scripts.
+    save_config_raw(cfg.model_dump(by_alias=True), path=path)
+
+
+def load_config(path: Path = CONFIG_PATH) -> LoginConfig:
+    with open(path, "r") as f:
+        raw = json.load(f)
+    return LoginConfig.model_validate(raw)