lr-gladiator 0.1.0__py3-none-any.whl

gladiator/__init__.py

@@ -0,0 +1,7 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# src/gladiator/__init__.py
+
+__all__ = ["ArenaClient", "load_config", "save_config"]
+from .arena import ArenaClient
+from .config import load_config, save_config

gladiator/arena.py

@@ -0,0 +1,505 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+# src/gladiator/arena.py
+from __future__ import annotations
+import subprocess
+import shlex
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import requests
+from .config import LoginConfig
+
+class ArenaError(RuntimeError):
+    pass
+
+class ArenaClient:
+    def __init__(self, cfg: LoginConfig):
+        self.cfg = cfg
+        self.session = requests.Session()
+        self.session.verify = cfg.verify_tls
+        # Default headers: explicitly request/submit JSON
+        self.session.headers.update({
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": "gladiator-arena/0.1",
+            "Arena-Usage-Reason": cfg.reason or "gladiator/cli",
+        })
+        if cfg.arena_session_id:
+            self.session.headers.update({"arena_session_id": cfg.arena_session_id})
+
+        self._debug = bool(int(os.environ.get("GLADIATOR_DEBUG", "0")))
+
+    # ---------- Utilities ----------
+    def _ensure_json(self, resp: requests.Response):
+        ctype = resp.headers.get("Content-Type", "").lower()
+        if "application/json" not in ctype:
+            snippet = resp.text[:400].replace("", " ")
+            raise ArenaError(
+                f"Expected JSON but got '{ctype or 'unknown'}' from {resp.url}. "
+                f"Status {resp.status_code}. Body starts with: {snippet}"
+            )
+        try:
+            return resp.json()
+        except Exception as e:
+            raise ArenaError(f"Failed to parse JSON from {resp.url}: {e}") from e
+
+    def _log(self, msg: str):
+        if self._debug:
+            print(f"[gladiator debug] {msg}")
+
+    def _try_json(self, resp: requests.Response) -> Optional[dict]:
+        """Best-effort JSON parse. Returns None if not JSON or parse fails."""
+        ctype = resp.headers.get("Content-Type", "").lower()
+        if "application/json" not in ctype:
+            return None
+        try:
+            data = resp.json()
+            return data if isinstance(data, dict) else {"data": data}
+        except Exception:
+            return None
+
+    # --- version picking helpers ---
+    @staticmethod
+    def _logical_key(f: Dict) -> str:
+        # Prefer any group-level id; fall back to normalized filename
+        return (
+            f.get("attachmentGroupGuid")
+            or f.get("attachmentGroupId")
+            or f.get("attachmentGuid")
+            or (f.get("name") or f.get("filename") or "").lower()
+        )
+
+    @staticmethod
+    def _version_of(f: Dict) -> int:
+        for k in ("version", "fileVersion", "versionNumber", "rev", "revision"):
+            v = f.get(k)
+            if v is None:
+                continue
+            try:
+                return int(v)
+            except Exception:
+                if isinstance(v, str) and len(v) == 1 and v.isalpha():
+                    return ord(v.upper()) - 64  # A->1
+        return -1
+
+    @staticmethod
+    def _timestamp_of(f: Dict):
+        from datetime import datetime
+        from email.utils import parsedate_to_datetime
+        for k in ("modifiedAt", "updatedAt", "lastModified", "lastModifiedDate", "effectiveDate", "createdAt"):
+            s = f.get(k)
+            if not s:
+                continue
+            try:
+                return datetime.fromisoformat(s.replace("Z", "+00:00"))
+            except Exception:
+                try:
+                    return parsedate_to_datetime(s)
+                except Exception:
+                    continue
+        return None
+
+    def _latest_files(self, files: List[Dict]) -> List[Dict]:
+        best: Dict[str, Dict] = {}
+        for f in files:
+            key = self._logical_key(f)
+            if not key:
+                continue
+            score = (self._version_of(f), self._timestamp_of(f) or 0)
+            prev = best.get(key)
+            if not prev:
+                f["_score"] = score
+                best[key] = f
+                continue
+            if score > prev.get("_score", (-1, 0)):
+                f["_score"] = score
+                best[key] = f
+        out = []
+        for v in best.values():
+            v.pop("_score", None)
+            out.append(v)
+        return out
+
+    # ---------- Public high-level methods ----------
+    def get_latest_approved_revision(self, item_number: str) -> str:
+        return self._api_get_latest_approved(item_number)
+
+
+    def list_files(self, item_number: str, revision: Optional[str] = None) -> List[Dict]:
+        target_guid = self._api_resolve_revision_guid(item_number, revision or "EFFECTIVE")
+        raw = self._api_list_files_by_item_guid(target_guid)
+        return self._latest_files(raw)
+    
+
+    def download_files(self, item_number: str, revision: Optional[str] = None, out_dir: Path = Path(".")) -> List[Path]:
+        files = self.list_files(item_number, revision)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        downloaded: List[Path] = []
+        for f in files:
+            url = f.get("downloadUrl") or f.get("url")
+            filename = f.get("filename") or f.get("name")
+            if not url or not filename:
+                continue
+            p = out_dir / filename
+            with self.session.get(url, stream=True, headers={"arena_session_id": self.cfg.arena_session_id or ""}) as r:
+                r.raise_for_status()
+                with open(p, "wb") as fh:
+                    for chunk in r.iter_content(128 * 1024):
+                        fh.write(chunk)
+            downloaded.append(p)
+        return downloaded
+
+    def upload_file_to_working(
+        self,
+        item_number: str,
+        file_path: Path,
+        reference: Optional[str] = None,
+        *,
+        title: Optional[str] = None,
+        category_name: str = "CAD Data",
+        file_format: Optional[str] = None,
+        description: Optional[str] = None,
+        primary: bool = True,
+        latest_edition_association: bool = True,
+        edition: str = "1",
+    ) -> Dict:
+        """
+        Update-if-exists-else-create semantics, matching the bash script:
+          1) Resolve EFFECTIVE GUID from item number
+          2) Resolve WORKING revision GUID (fail if none)
+          3) Find existing file by exact filename (WORKING first, then EFFECTIVE)
+             - If found: POST /files/{fileGuid}/content (multipart)
+             - Else:     POST /items/{workingGuid}/files (multipart) with file.edition
+        """
+        return self._api_upload_or_update_file(
+            item_number=item_number,
+            file_path=file_path,
+            reference=reference,
+            title=title,
+            category_name=category_name,
+            file_format=file_format,
+            description=description,
+            primary=primary,
+            latest_edition_association=latest_edition_association,
+            edition=edition,
+        )
+
+    # ---------- API-mode (HTTP) ----------
+    def _api_base(self) -> str:
+        return self.cfg.base_url.rstrip("/")
+
+    def _api_get_latest_approved(self, item_number: str) -> str:
+        item_guid = self._api_resolve_item_guid(item_number)
+        url = f"{self._api_base()}/items/{item_guid}/revisions"
+        self._log(f"GET {url}")
+        r = self.session.get(url)
+        if r.status_code == 404:
+            raise ArenaError(f"Item {item_number} not found")
+        r.raise_for_status()
+        data = self._ensure_json(r)
+        revs = data.get("results", data if isinstance(data, list) else [])
+        if not isinstance(revs, list):
+            raise ArenaError(f"Unexpected revisions payload for item {item_number}")
+
+        # Arena marks the currently effective (approved) revision as:
+        #   - revisionStatus == "EFFECTIVE"   (string)
+        #   - OR status == 1                  (numeric)
+        effective = [
+            rv for rv in revs
+            if (str(rv.get("revisionStatus") or "").upper() == "EFFECTIVE") or (rv.get("status") == 1)
+        ]
+        if not effective:
+            raise ArenaError(f"No approved/released revisions for item {item_number}")
+
+        # Prefer the one that is not superseded; otherwise fall back to the most recently superseded.
+        current = next((rv for rv in effective if not rv.get("supersededDateTime")), None)
+        if not current:
+            # sort by supersededDateTime (None last) then by number/name as a stable tie-breaker
+            def _sd(rv):
+                dt = rv.get("supersededDateTime")
+                return dt or "0000-00-00T00:00:00Z"
+            effective.sort(key=_sd)
+            current = effective[-1]
+
+        # The human-visible revision is under "number" (e.g., "B3"); fall back defensively.
+        rev_label = current.get("number") or current.get("name") or current.get("revision")
+        if not rev_label:
+            raise ArenaError(f"Could not determine revision label for item {item_number}")
+        return rev_label
+
+    def _api_list_files(self, item_number: str) -> List[Dict]:
+        item_guid = self._api_resolve_item_guid(item_number)
+        url = f"{self._api_base()}/items/{item_guid}/files"
+        self._log(f"GET {url}")
+        r = self.session.get(url)
+        r.raise_for_status()
+        data = self._ensure_json(r)
+        rows = data.get("results", data if isinstance(data, list) else [])
+        norm: List[Dict] = []
+        for row in rows:
+            f = row.get("file", {}) if isinstance(row, dict) else {}
+            file_guid = f.get("guid") or f.get("id")
+            norm.append({
+                "id": row.get("guid") or row.get("id"),         # association id
+                "fileGuid": file_guid,                           # actual file id
+                "name": f.get("name") or f.get("title"),
+                "filename": f.get("name") or f.get("title"),
+                "size": f.get("size"),
+                "checksum": f.get("checksum") or f.get("md5"),
+                "downloadUrl": f"{self._api_base()}/files/{file_guid}/content" if file_guid else None,
+                # for “pick latest” helper:
+                "version": f.get("version") or f.get("edition"),
+                "updatedAt": f.get("lastModifiedDateTime") or f.get("lastModifiedDate") or f.get("creationDateTime"),
+                "attachmentGroupGuid": row.get("guid"),
+            })
+        return norm
+
+    def _api_resolve_revision_guid(self, item_number: str, selector: str | None) -> str:
+        """Return the item GUID for the requested revision selector."""
+        # Resolve base item (effective) guid from number
+        effective_guid = self._api_resolve_item_guid(item_number)
+
+        # If no selector, we default to EFFECTIVE
+        sel = (selector or "EFFECTIVE").strip().upper()
+
+        # Fetch revisions
+        url = f"{self._api_base()}/items/{effective_guid}/revisions"
+        self._log(f"GET {url}")
+        r = self.session.get(url); r.raise_for_status()
+        data = self._ensure_json(r)
+        revs = data.get("results", data if isinstance(data, list) else [])
+
+        def pick(pred):
+            for rv in revs:
+                if pred(rv):
+                    return rv.get("guid")
+            return None
+
+        # Named selectors
+        if sel in {"WORKING"}:
+            guid = pick(lambda rv: (rv.get("revisionStatus") or "").upper() == "WORKING" or rv.get("status") == 0)
+            if not guid:
+                raise ArenaError("No WORKING revision exists for this item.")
+            return guid
+
+        if sel in {"EFFECTIVE", "APPROVED", "RELEASED"}:
+            # Prefer the one not superseded
+            eff = [rv for rv in revs if (rv.get("revisionStatus") or "").upper() == "EFFECTIVE" or rv.get("status") == 1]
+            if not eff:
+                raise ArenaError("No approved/effective revision exists for this item.")
+            current = next((rv for rv in eff if not rv.get("supersededDateTime")), eff[-1])
+            return current.get("guid")
+
+        # Specific label (e.g., "A", "B2")
+        guid = pick(lambda rv: (rv.get("number") or rv.get("name")) and str(rv.get("number") or rv.get("name")).upper() == sel)
+        if not guid:
+            raise ArenaError(f'Revision "{selector}" not found for item {item_number}.')
+        return guid
+
+    def _api_list_files_by_item_guid(self, item_guid: str) -> list[dict]:
+        url = f"{self._api_base()}/items/{item_guid}/files"
+        self._log(f"GET {url}")
+        r = self.session.get(url); r.raise_for_status()
+        data = self._ensure_json(r)
+        rows = data.get("results", data if isinstance(data, list) else [])
+        # … keep existing normalization from _api_list_files() …
+        norm = []
+        for row in rows:
+            f = row.get("file", {}) if isinstance(row, dict) else {}
+            file_guid = f.get("guid") or f.get("id")
+            norm.append({
+                "id": row.get("guid") or row.get("id"),
+                "fileGuid": file_guid,
+                "name": f.get("name") or f.get("title"),
+                "filename": f.get("name") or f.get("title"),
+                "size": f.get("size"),
+                "checksum": f.get("checksum") or f.get("md5"),
+                "downloadUrl": f"{self._api_base()}/files/{file_guid}/content" if file_guid else None,
+                "version": f.get("version") or f.get("edition"),
+                "updatedAt": f.get("lastModifiedDateTime") or f.get("lastModifiedDate") or f.get("creationDateTime"),
+                "attachmentGroupGuid": row.get("guid"),
+            })
+        return norm    
+
+    def _api_upload_or_update_file(
+        self,
+        *,
+        item_number: str,
+        file_path: Path,
+        reference: Optional[str],
+        title: Optional[str],
+        category_name: str,
+        file_format: Optional[str],
+        description: Optional[str],
+        primary: bool,
+        latest_edition_association: bool,
+        edition: str,
+    ) -> Dict:
+        if not file_path.exists() or not file_path.is_file():
+            raise ArenaError(f"File not found: {file_path}")
+
+        # 0) Resolve EFFECTIVE revision guid from item number
+        effective_guid = self._api_resolve_item_guid(item_number)
+
+        # 1) Resolve WORKING revision guid
+        revs_url = f"{self._api_base()}/items/{effective_guid}/revisions"
+        self._log(f"GET {revs_url}")
+        r = self.session.get(revs_url)
+        r.raise_for_status()
+        data = self._ensure_json(r)
+        rows = data.get("results", data if isinstance(data, list) else [])
+        working_guid = None
+        for rv in rows:
+            if (str(rv.get("revisionStatus") or "").upper() == "WORKING") or (rv.get("status") == 0):
+                working_guid = rv.get("guid")
+                break
+        if not working_guid:
+            raise ArenaError(
+                "No WORKING revision exists for this item. Create a working revision in Arena, then retry."
+            )
+
+        # Helper to list associations for a given item/revision guid
+        def _list_assocs(item_guid: str) -> list:
+            url = f"{self._api_base()}/items/{item_guid}/files"
+            self._log(f"GET {url}")
+            lr = self.session.get(url)
+            lr.raise_for_status()
+            payload = self._ensure_json(lr)
+            return payload.get("results", payload if isinstance(payload, list) else [])
+
+        # Try to find existing association by exact filename (WORKING first, then EFFECTIVE)
+        filename = file_path.name
+        assoc = None
+        for guid in (working_guid, effective_guid):
+            assocs = _list_assocs(guid)
+            # prefer primary && latestEditionAssociation, then any by name
+            prim_latest = [a for a in assocs if a.get("primary") and a.get("latestEditionAssociation")
+                           and ((a.get("file") or {}).get("name") == filename)]
+            if prim_latest:
+                assoc = prim_latest[0]
+                break
+            any_by_name = [a for a in assocs if (a.get("file") or {}).get("name") == filename]
+            if any_by_name:
+                assoc = any_by_name[0]
+                break
+
+        # If an existing file is found: update its content (new edition)
+        if assoc:
+            file_guid = (assoc.get("file") or {}).get("guid")
+            if not file_guid:
+                raise ArenaError("Existing association found but no file.guid present.")
+            post_url = f"{self._api_base()}/files/{file_guid}/content"
+            self._log(f"POST {post_url} (multipart content update)")
+            with open(file_path, "rb") as fp:
+                files = {"content": (filename, fp, "application/octet-stream")}
+                existing_ct = self.session.headers.pop("Content-Type", None)
+                try:
+                    ur = self.session.post(post_url, files=files)
+                finally:
+                    if existing_ct is not None:
+                        self.session.headers["Content-Type"] = existing_ct
+            ur.raise_for_status()
+            # Many tenants return 201 with no JSON for content updates. Be flexible.
+            data = self._try_json(ur)
+            if data is None:
+                # Synthesize a small success payload with whatever we can glean.
+                return {
+                    "ok": True,
+                    "status": ur.status_code,
+                    "fileGuid": file_guid,
+                    "location": ur.headers.get("Location"),
+                }
+            return data
+
+        # Else: create a new association on WORKING
+        # 2) Resolve file category guid by name (default: CAD Data)        cats_url = f"{self._api_base()}/settings/files/categories"
+        self._log(f"GET {cats_url}")
+        r = self.session.get(cats_url)
+        r.raise_for_status()
+        cats = self._ensure_json(r).get("results", [])
+        cat_guid = None
+        for c in cats:
+            if c.get("name") == category_name and (c.get("parentCategory") or {}).get("name") in {"Internal File", None}:
+                cat_guid = c.get("guid")
+                break
+        if not cat_guid:
+            raise ArenaError(f'File category "{category_name}" not found or not allowed.')
+
+        # 3) Prepare multipart (create association)
+        title = title or file_path.stem
+        file_format = file_format or (file_path.suffix[1:].lower() if file_path.suffix else "bin")
+        description = description or "Uploaded via gladiator"
+
+        files = {
+            "content": (file_path.name, open(file_path, "rb"), "application/octet-stream"),
+        }
+        # NOTE: nested field names are sent in `data`, not `files`
+        data_form = {
+             "file.title": title,
+             "file.name": filename,
+             "file.description": description,
+             "file.category.guid": cat_guid,
+             "file.format": file_format,
+             "file.edition": str(edition),
+             "file.storageMethodName": "FILE",
+             "file.private": "false",
+             "primary": "true" if primary else "false",
+             "latestEditionAssociation": "true" if latest_edition_association else "false",
+         }
+        if reference:
+            data_form["reference"] = reference
+
+        # 4) POST to /items/{workingGuid}/files (multipart). Ensure Content-Type not pinned.
+        post_url = f"{self._api_base()}/items/{working_guid}/files"
+        self._log(f"POST {post_url} (multipart)")
+
+        with open(file_path, "rb") as fp:
+            files = {"content": (filename, fp, "application/octet-stream")}
+            existing_ct = self.session.headers.pop("Content-Type", None)
+            try:
+                cr = self.session.post(post_url, data=data_form, files=files)
+            finally:
+                if existing_ct is not None:
+                    self.session.headers["Content-Type"] = existing_ct
+        cr.raise_for_status()
+        resp = self._ensure_json(cr)
+
+        # Normalize common fields we use elsewhere
+        row = resp if isinstance(resp, dict) else {}
+        f = row.get("file", {})
+        return {
+            "associationGuid": row.get("guid"),
+            "primary": row.get("primary"),
+            "latestEditionAssociation": row.get("latestEditionAssociation"),
+            "file": {
+                "guid": f.get("guid"),
+                "title": f.get("title"),
+                "name": f.get("name"),
+                "size": f.get("size"),
+                "format": f.get("format"),
+                "category": (f.get("category") or {}).get("name"),
+                "edition": f.get("edition"),
+                "lastModifiedDateTime": f.get("lastModifiedDateTime"),
+            },
+            "downloadUrl": f"{self._api_base()}/files/{(f or {}).get('guid')}/content" if f.get("guid") else None,
+        }
+
+    def _api_resolve_item_guid(self, item_number: str) -> str:
+        url = f"{self._api_base()}/items/"
+        params = {"number": item_number, "limit": 1, "responseview": "minimal"}
+        self._log(f"GET {url} params={params}")
+        r = self.session.get(url, params=params)
+        r.raise_for_status()
+        data = self._ensure_json(r)
+        results = data.get("results") if isinstance(data, dict) else data
+        if not results:
+            raise ArenaError(f"Item number {item_number} not found")
+        guid = (results[0].get("guid") or results[0].get("id") or results[0].get("itemId"))
+        if not guid:
+            raise ArenaError("API response missing item GUID")
+        return guid
+
+    def _run(self, cmd: str) -> Tuple[int, str, str]:
+        proc = subprocess.run(cmd, shell=True, check=False, capture_output=True, text=True)
+        return proc.returncode, proc.stdout.strip(), proc.stderr.strip()

gladiator/cli.py

@@ -0,0 +1,158 @@
+#! /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 getpass import getpass
+import requests
+import sys
+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")
+
+@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.
+
+    This performs a `/login` call against Arena and stores the JSON (including arenaSessionId) in login.json.
+    """
+    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"
+    resp = sess.post(url, headers=headers, json={"email": username, "password": password})
+    try:
+        resp.raise_for_status()
+    except Exception as e:
+        typer.secho(f"Login failed: {e} Body: {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,
+    })
+    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."""
+    try:
+        rev = _client().get_latest_approved_revision(item)
+        if format == "json":
+            json.dump({"article": item, "revision": rev}, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            print(rev)
+    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"),
+):
+    try:
+        files = _client().list_files(item, revision)
+        if format == "json":
+            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("Size", justify="right")
+        table.add_column("Checksum")
+        for f in files:
+            table.add_row(str(f.get("filename")), str(f.get("size")), str(f.get("checksum")))
+        print(table)
+    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: Path = typer.Option(Path("downloads"), "--out", help="Output directory"),
+    format: Optional[str] = typer.Option(None, "--format", "-f", help="Output format: human (default) or json"),
+):
+    try:
+        paths = _client().download_files(item, revision, out_dir=out)
+        for p in paths:
+            print(str(p))
+    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("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(True, "--primary/--no-primary", help="Mark association as primary"),
+    edition: str = typer.Option("1", "--edition", help="Edition number when creating a new association (default: 1)"),
+):
+    """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
+        )
+        print(json.dumps(result, indent=2))
+    except ArenaError as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+
+
+if __name__ == "__main__":
+    app()

gladiator/config.py

@@ -0,0 +1,52 @@
+#! /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
+
+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):
+    # 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
+
+    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)
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    try:
+        os.chmod(path, 0o600)
+    except PermissionError:
+        pass
+
+
+def save_config(cfg: LoginConfig, path: Path = CONFIG_PATH) -> None:
+    save_config_raw(cfg.model_dump(by_alias=True))
+
+
+def load_config(path: Path = CONFIG_PATH) -> LoginConfig:
+    with open(path, "r") as f:
+        raw = json.load(f)
+    return LoginConfig(**raw)

lr_gladiator-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: lr-gladiator
+Version: 0.1.0
+Summary: CLI and Python client for Arena PLM (app.bom.com): login, get revisions, list/download attachments, and upload to working revisions.
+Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
+License: MIT
+Keywords: Arena,PLM,BOM,attachments,CLI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.7
+Requires-Dist: pydantic>=2.8
+Provides-Extra: dev
+Requires-Dist: build>=1.2.1; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Dynamic: license-file
+
+# gladiator-arena
+
+CLI + Python client for interacting with the Arena PLM.
+
+## Install
+
+```bash
+pip install gladiator-arena
+```
+
+## Quick start
+
+### 1) Create `login.json`
+
+Interactive:
+
+```bash
+gladiator login --subdomain acme
+```
+
+CI/CD friendly:
+
+```bash
+gladiator login --subdomain acme --api-key "$ARENA_API_KEY" --ci
+```
+
+To use your existing scripts while prototyping:
+
+```bash
+gladiator login --subdomain acme --mode bash --scripts-root /path/to/scripts
+```
+
+`login.json` is stored at `~/.config/gladiator/login.json` by default.
+
+### 2) Queries
+
+Get latest approved revision for an item:
+
+```bash
+gladiator latest-approved ABC-1234
+```
+
+List files on an item (defaults to latest approved):
+
+```bash
+gladiator list-files ABC-1234
+```
+
+Download files:
+
+```bash
+gladiator get-files ABC-1234 --out downloads/
+```
+
+Upload a file to the working revision (will refuse if the revision is approved/released):
+
+```bash
+gladiator upload-file ABC-1234 ./datasheet.pdf --reference datasheet
+```
+
+## Programmatic use
+
+```python
+from gladiator import ArenaClient, load_config
+client = ArenaClient(load_config())
+rev = client.get_latest_approved_revision("ABC-1234")
+files = client.list_files("ABC-1234", rev)
+```
+
+## Development
+
+```bash
+python -m pip install -e .[dev]
+python -m build
+```
+
+## FAQ
+
+- **Where is the config kept?** `~/.config/gladiator/login.json` (override via `GLADIATOR_CONFIG`).
+- **Auth method?** Prefer API key. Username/password is supported to be CI-friendly but avoid storing passwords when possible.
+- **Approved states?** By default any state labelled `Approved` or `Released` is treated as approved. Adjust the code if your tenant uses custom labels.

lr_gladiator-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gladiator/__init__.py,sha256=kVgJiGDD6714tJ3SN6mdao3rdVO57jlMvLMHAFjHX4A,207
+gladiator/arena.py,sha256=3_Ry7_7YIUNHtlxo0WLwq0q4CVGwCmikzoYnQIZy-DE,21651
+gladiator/cli.py,sha256=ugquxfry1Qx6iYbNVglXgYV9XPryAzYmXlLBxAF6JTc,6557
+gladiator/config.py,sha256=pnuVrcW8yafxMB7RU9wyi_4jS_oMBIuNryfet203Wng,1738
+lr_gladiator-0.1.0.dist-info/licenses/LICENSE,sha256=2CEtbEagerjoU3EDSk-eTM5LKgI_RpiVIOh3_CV4kms,1069
+lr_gladiator-0.1.0.dist-info/METADATA,sha256=nOzlohzF7-daFGFF1jq9d1_dn9PxYQGtlefV75gplV0,2498
+lr_gladiator-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lr_gladiator-0.1.0.dist-info/entry_points.txt,sha256=SLka4w7iGS2B8HrbeZyNk5mxaIC6QKcv93us1OaWNwQ,48
+lr_gladiator-0.1.0.dist-info/top_level.txt,sha256=tfrcAmK7_7Lf63w7kWy0wv_Qg9RrcFWGoins1-jGUF4,10
+lr_gladiator-0.1.0.dist-info/RECORD,,

lr_gladiator-0.1.0.dist-info/WHEEL

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

lr_gladiator-0.1.0.dist-info/entry_points.txt

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

lr_gladiator-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+
+Copyright (c) 2025 Your Name
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lr_gladiator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gladiator