lr-gladiator 0.4.0__py3-none-any.whl → 0.14.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

@@ -8,33 +8,74 @@ 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
+
+
+MAX_EDITION_LENGTH = 16
+
+
+def _truncate_edition(value: Optional[str]) -> Optional[str]:
+    """Clamp edition strings to Arena's 16-character limit."""
+    if value is None:
+        return None
+    return str(value)[:MAX_EDITION_LENGTH]
+
 
 @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"),
+    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"),
+    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.
-
-    This performs a `/login` call against Arena and stores the JSON (including arenaSessionId) in login.json.
-    """
+    """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")
+        raise typer.BadParameter(
+            "Provide --username and --password (or set env vars) for --ci mode"
+        )
 
     # Perform login
     sess = requests.Session()
@@ -46,21 +87,22 @@ def login(
         "User-Agent": "gladiator-arena/0.1",
     }
     url = f"{(base_url or '').rstrip('/')}/login"
-    resp = sess.post(url, headers=headers, json={"email": username, "password": password})
     try:
-        resp.raise_for_status()
+        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: {resp.text[:400]}", fg=typer.colors.RED, err=True)
+        typer.secho(
+            f"Login failed: {e} Body: {getattr(resp, 'text', '')[:400]}",
+            fg=typer.colors.RED,
+            err=True,
+        )
         raise typer.Exit(2)
 
     data = resp.json()
-
-    # Merge our client settings alongside the session info into the same file (compatible with your bash scripts)
-    data.update({
-        "base_url": base_url,
-        "verify_tls": verify_tls,
-        "reason": reason,
-    })
+    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]")
 
@@ -73,16 +115,25 @@ def _client() -> ArenaClient:
 @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"),
+    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:
-        rev = _client().get_latest_approved_revision(item)
-        if format == "json":
+        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)
@@ -91,23 +142,117 @@ def latest_approved(
 @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"),
+    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:
-        files = _client().list_files(item, revision)
-        if format == "json":
-            json.dump({"article": item, "revision": revision, "files": files}, sys.stdout, indent=2)
+        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("Name")
+        table.add_column("Title")
+        table.add_column("Filename")
         table.add_column("Size", justify="right")
-        table.add_column("Checksum")
+        table.add_column("Edition")
+        table.add_column("Type")
+        table.add_column("Location")
         for f in files:
-            table.add_row(str(f.get("filename")), str(f.get("size")), str(f.get("checksum")))
+            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)
@@ -116,13 +261,47 @@ def list_files(
 @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: Path = typer.Option(Path("downloads"), "--out", help="Output directory"),
+    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:
-        paths = _client().download_files(item, revision, out_dir=out)
+        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)
@@ -132,25 +311,134 @@ def get_files(
 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("CAD Data", "--category", help='File category name (default: "CAD Data")'),
-    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("1", "--edition", help="Edition number when creating a new association (default: 1)"),
+    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 of max 16 characters (default: SHA256[:16] checksum of 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)."""
+    """
+    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:
-        result = _client().upload_file_to_working(
-            item, file, reference,
-            title=title, category_name=category, file_format=file_format,
-            description=description, primary=primary, edition=edition
-        )
+        edition = _truncate_edition(edition)
+        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 of max 16 characters (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:
+        edition = _truncate_edition(edition)
+        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__":

gladiator/config.py

@@ -2,18 +2,27 @@
 # -*- 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
 
-CONFIG_HOME = Path(os.environ.get("GLADIATOR_CONFIG_HOME", Path.home() / ".config" / "gladiator"))
+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")
+    base_url: str = Field(
+        "https://api.arenasolutions.com/v1", description="Arena REST API base URL"
+    )
     verify_tls: bool = True
 
     # Auth options
@@ -28,9 +37,6 @@ class LoginConfig(BaseModel):
     workspace_request_limit: Optional[int] = Field(None, alias="workspaceRequestLimit")
     reason: Optional[str] = None
 
-    class Config:
-        populate_by_name = True
-
 
 def save_config_raw(data: Dict[str, Any], path: Path = CONFIG_PATH) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -39,14 +45,16 @@ def save_config_raw(data: Dict[str, Any], path: Path = CONFIG_PATH) -> None:
     try:
         os.chmod(path, 0o600)
     except PermissionError:
+        # Best-effort on non-POSIX filesystems
         pass
 
 
 def save_config(cfg: LoginConfig, path: Path = CONFIG_PATH) -> None:
-    save_config_raw(cfg.model_dump(by_alias=True))
+    # 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(**raw)
+    return LoginConfig.model_validate(raw)