lr-gladiator 0.5.0__tar.gz → 0.7.0__tar.gz

{lr_gladiator-0.5.0/src/lr_gladiator.egg-info → lr_gladiator-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-gladiator
-Version: 0.5.0
+Version: 0.7.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

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-gladiator"
-version = "0.5.0"
+version = "0.7.0"
 description = "CLI and Python client for Arena PLM (app.bom.com): login, get revisions, list/download attachments, and upload to working revisions."
 readme = "README.md"
 requires-python = ">=3.9"

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/src/gladiator/__init__.py

@@ -4,4 +4,4 @@
 
 __all__ = ["ArenaClient", "load_config", "save_config"]
 from .arena import ArenaClient
-from .config import load_config, save_config
+from .config import load_config, save_config

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/src/gladiator/arena.py

@@ -10,21 +10,25 @@ 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",
-        })
+        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})
 
@@ -87,7 +91,15 @@ class ArenaClient:
     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"):
+
+        for k in (
+            "modifiedAt",
+            "updatedAt",
+            "lastModified",
+            "lastModifiedDate",
+            "effectiveDate",
+            "createdAt",
+        ):
             s = f.get(k)
             if not s:
                 continue
@@ -125,29 +137,107 @@ class ArenaClient:
     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")
+    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]:
+    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:
+            # Skip associations with no blob
+            if not f.get("haveContent", True):
+                self._log(
+                    f"Skip {item_number}: file {f.get('filename')} has no content"
+                )
+                continue
+
             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)
+            try:
+                with self.session.get(
+                    url,
+                    stream=True,
+                    headers={"arena_session_id": self.cfg.arena_session_id or ""},
+                ) as r:
+                    # If the blob is missing/forbidden, don’t abort the whole command
+                    if r.status_code in (400, 403, 404):
+                        self._log(
+                            f"Skip {item_number}: {filename} content unavailable "
+                            f"(HTTP {r.status_code})"
+                        )
+                        continue
+                    r.raise_for_status()
+                    with open(p, "wb") as fh:
+                        for chunk in r.iter_content(128 * 1024):
+                            fh.write(chunk)
+                downloaded.append(p)
+            except requests.HTTPError as e:
+                # Be resilient: log and continue
+                self._log(f"Download failed for {filename}: {e}")
+                continue
+        return downloaded
+
+    def download_files_recursive(
+        self,
+        item_number: str,
+        revision: Optional[str] = None,
+        out_dir: Path = Path("."),
+        *,
+        max_depth: Optional[int] = None,
+    ) -> List[Path]:
+        """
+        Download files for `item_number` AND, recursively, for all subassemblies
+        discovered via the BOM. Each child item is placed under a subdirectory:
+            <out_dir>/<child_item_number>/
+        Root files go directly in <out_dir>/.
+
+        Depth semantics match `get_bom(..., recursive=True, max_depth=...)`.
+        """
+        # Ensure the root directory exists
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+        downloaded: List[Path] = []
+        # 1) Download files for the root item into out_dir
+        downloaded.extend(self.download_files(item_number, revision, out_dir=out_dir))
+
+        # 2) Expand BOM recursively and collect unique child item numbers
+        lines = self.get_bom(
+            item_number,
+            revision,
+            recursive=True,
+            max_depth=max_depth,
+        )
+        seen_children = set()
+        for ln in lines:
+            child_num = (ln or {}).get("itemNumber")
+            if not child_num or child_num == item_number:
+                continue
+            if child_num in seen_children:
+                continue
+            seen_children.add(child_num)
+
+            # Place each child's files under <out_dir>/<child_num>/
+            child_dir = out_dir / child_num
+            downloaded.extend(
+                self.download_files(child_num, revision, out_dir=child_dir)
+            )
+
         return downloaded
 
     def upload_file_to_working(
@@ -185,15 +275,52 @@ class ArenaClient:
             edition=edition,
         )
 
-    def get_bom(self, item_number: str, revision: Optional[str] = None) -> List[Dict]:
+    def get_bom(
+        self,
+        item_number: str,
+        revision: Optional[str] = None,
+        *,
+        recursive: bool = False,
+        max_depth: Optional[int] = None,
+    ) -> List[Dict]:
         """
         Return a normalized list of BOM lines for the given item.
 
         By default this fetches the EFFECTIVE (approved) revision's BOM.
         Use revision="WORKING" or a specific label (e.g., "B2") to override.
+
+        If recursive=True, expand subassemblies depth-first. max_depth limits the recursion
+        depth (1 = only direct children). If omitted, recursion is unlimited.
+        """
+        selector = (revision or "EFFECTIVE").strip()
+        out: List[Dict] = []
+        self._bom_expand(
+            root_item=item_number,
+            selector=selector,
+            out=out,
+            recursive=recursive,
+            max_depth=max_depth,
+            _level=0,
+            _seen=set(),
+        )
+        return out
+
+    # === Internal: single fetch + normalization (your original logic) ===
+
+    def _fetch_bom_normalized(self, item_number: str, selector: str) -> List[Dict]:
+        """
+        Fetch and normalize the BOM for item_number with the given revision selector.
+        Falls back WORKING -> EFFECTIVE if selector is WORKING and no WORKING exists.
         """
         # 1) Resolve the exact revision GUID we want the BOM for
-        target_guid = self._api_resolve_revision_guid(item_number, revision or "EFFECTIVE")
+        try:
+            target_guid = self._api_resolve_revision_guid(item_number, selector)
+        except ArenaError:
+            if selector.strip().upper() == "WORKING":
+                # fallback: try EFFECTIVE for children that don't have a WORKING revision
+                target_guid = self._api_resolve_revision_guid(item_number, "EFFECTIVE")
+            else:
+                raise
 
         # 2) GET /items/{guid}/bom
         url = f"{self._api_base()}/items/{target_guid}/bom"
@@ -206,24 +333,81 @@ class ArenaClient:
         norm: List[Dict] = []
         for row in rows:
             itm = row.get("item", {}) if isinstance(row, dict) else {}
-            norm.append({
-                # association/line
-                "guid": row.get("guid"),
-                "lineNumber": row.get("lineNumber"),
-                "notes": row.get("notes"),
-                "quantity": row.get("quantity"),
-                "refDes": row.get("refDes") or row.get("referenceDesignators") or "",
-                # child item
-                "itemGuid": itm.get("guid") or itm.get("id"),
-                "itemNumber": itm.get("number"),
-                "itemName": itm.get("name"),
-                "itemRevision": itm.get("revisionNumber"),
-                "itemRevisionStatus": itm.get("revisionStatus"),
-                "itemUrl": (itm.get("url") or {}).get("api"),
-                "itemAppUrl": (itm.get("url") or {}).get("app"),
-            })
+            norm.append(
+                {
+                    # association/line
+                    "guid": row.get("guid"),
+                    "lineNumber": row.get("lineNumber"),
+                    "notes": row.get("notes"),
+                    "quantity": row.get("quantity"),
+                    "refDes": row.get("refDes")
+                    or row.get("referenceDesignators")
+                    or "",
+                    # child item
+                    "itemGuid": itm.get("guid") or itm.get("id"),
+                    "itemNumber": itm.get("number"),
+                    "itemName": itm.get("name"),
+                    "itemRevision": itm.get("revisionNumber"),
+                    "itemRevisionStatus": itm.get("revisionStatus"),
+                    "itemUrl": (itm.get("url") or {}).get("api"),
+                    "itemAppUrl": (itm.get("url") or {}).get("app"),
+                }
+            )
         return norm
 
+    # === Internal: recursive expansion ===
+
+    def _bom_expand(
+        self,
+        *,
+        root_item: str,
+        selector: str,
+        out: List[Dict],
+        recursive: bool,
+        max_depth: Optional[int],
+        _level: int,
+        _seen: set,
+    ) -> None:
+        # avoid cycles
+        if root_item in _seen:
+            return
+        _seen.add(root_item)
+
+        rows = self._fetch_bom_normalized(root_item, selector)
+
+        # attach level and parentNumber (useful in JSON + for debugging)
+        for r in rows:
+            r["level"] = _level
+            r["parentNumber"] = root_item
+            out.append(r)
+
+        if not recursive:
+            return
+
+        # depth check: if max_depth=1, only expand children once (level 0 -> level 1)
+        if max_depth is not None and _level >= max_depth:
+            return
+
+        # expand each child that looks like an assembly (if it has a BOM; empty BOM is okay)
+        for r in rows:
+            child_num = r.get("itemNumber")
+            if not child_num:
+                continue
+            try:
+                # Recurse; keep same selector, with WORKING->EFFECTIVE fallback handled in _fetch_bom_normalized
+                self._bom_expand(
+                    root_item=child_num,
+                    selector=selector,
+                    out=out,
+                    recursive=True,
+                    max_depth=max_depth,
+                    _level=_level + 1,
+                    _seen=_seen,
+                )
+            except ArenaError:
+                # Child might not have a BOM; skip silently
+                continue
+
     def _api_base(self) -> str:
         return self.cfg.base_url.rstrip("/")
 
@@ -244,26 +428,35 @@ class ArenaClient:
         #   - 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)
+            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)
+        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")
+        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}")
+            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]:
@@ -278,19 +471,27 @@ class ArenaClient:
         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"),
-            })
+            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"),
+                    "haveContent": f.get("haveContent", True),
+                    "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_resolve_revision_guid(self, item_number: str, selector: str | None) -> str:
@@ -304,7 +505,8 @@ class ArenaClient:
         # 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()
+        r = self.session.get(url)
+        r.raise_for_status()
         data = self._ensure_json(r)
         revs = data.get("results", data if isinstance(data, list) else [])
 
@@ -316,21 +518,36 @@ class ArenaClient:
 
         # Named selectors
         if sel in {"WORKING"}:
-            guid = pick(lambda rv: (rv.get("revisionStatus") or "").upper() == "WORKING" or rv.get("status") == 0)
+            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]
+            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. Try using revision 'WORKING'.")
-            current = next((rv for rv in eff if not rv.get("supersededDateTime")), eff[-1])
+                raise ArenaError(
+                    "No approved/effective revision exists for this item. Try using revision 'WORKING'."
+                )
+            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)
+        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
@@ -338,7 +555,8 @@ class ArenaClient:
     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()
+        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() …
@@ -346,19 +564,28 @@ class ArenaClient:
         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    
+            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"),
+                    "haveContent": f.get("haveContent", True),
+                    "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,
@@ -389,7 +616,9 @@ class ArenaClient:
         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):
+            if (str(rv.get("revisionStatus") or "").upper() == "WORKING") or (
+                rv.get("status") == 0
+            ):
                 working_guid = rv.get("guid")
                 break
         if not working_guid:
@@ -412,12 +641,19 @@ class ArenaClient:
         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)]
+            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]
+            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
@@ -459,30 +695,44 @@ class ArenaClient:
         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}:
+            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.')
+            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")
+        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")}
+        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.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",
-         }
+            "file.title": title,
+            "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
 
@@ -518,7 +768,11 @@ class ArenaClient:
                 "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,
+            "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:
@@ -531,11 +785,15 @@ class ArenaClient:
         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"))
+        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)
+        proc = subprocess.run(
+            cmd, shell=True, check=False, capture_output=True, text=True
+        )
         return proc.returncode, proc.stdout.strip(), proc.stderr.strip()

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/src/gladiator/cli.py

@@ -16,14 +16,25 @@ 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"),
+    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.
 
@@ -34,7 +45,9 @@ def login(
     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 +59,27 @@ 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})
+    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)
+        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,
-    })
+    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,7 +92,9 @@ 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."""
     try:
@@ -94,13 +115,23 @@ 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"
+    ),
 ):
     try:
         files = _client().list_files(item, revision)
         if format == "json":
-            json.dump({"article": item, "revision": revision, "files": files}, sys.stdout, indent=2)
+            json.dump(
+                {"article": item, "revision": revision, "files": files},
+                sys.stdout,
+                indent=2,
+            )
             sys.stdout.write("\n")
             return
 
@@ -109,7 +140,9 @@ def list_files(
         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")))
+            table.add_row(
+                str(f.get("filename")), str(f.get("size")), str(f.get("checksum"))
+            )
         print(table)
     except requests.HTTPError as e:
         typer.secho(f"Arena request failed: {e}", fg=typer.colors.RED, err=True)
@@ -118,15 +151,34 @@ def list_files(
         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"'),
+    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."""
     try:
-        lines = _client().get_bom(item, revision)
+        lines = _client().get_bom(
+            item, revision, recursive=recursive, max_depth=max_depth
+        )
+
         if output.lower() == "json":
             print(json.dumps({"count": len(lines), "results": lines}, indent=2))
             return
@@ -138,12 +190,15 @@ def bom(
         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  # 2 spaces per level
             table.add_row(
                 str(ln.get("lineNumber") or ""),
                 str(ln.get("quantity") or ""),
                 str(ln.get("itemNumber") or ""),
-                str(ln.get("itemName") or ""),
+                f"{indent}{str(ln.get('itemName') or '')}",
                 str(ln.get("refDes") or ""),
             )
         print(table)
@@ -154,14 +209,39 @@ def bom(
         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"),
+    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).",
+    ),
 ):
     try:
-        paths = _client().download_files(item, revision, out_dir=out)
+        out_dir = out or Path(item)  # article numbers are never files; safe as dir name
+        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:
@@ -176,21 +256,45 @@ 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(
+        "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)",
+    ),
 ):
     """If a file with the same filename exists: update its content (new edition).
-     Otherwise: create a new association on the WORKING revision (requires --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
+            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:

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/src/gladiator/config.py

@@ -8,12 +8,17 @@ 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_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")
+    base_url: str = Field(
+        "https://api.arenasolutions.com/v1", description="Arena REST API base URL"
+    )
     verify_tls: bool = True
 
     # Auth options
@@ -49,4 +54,4 @@ def save_config(cfg: LoginConfig, path: Path = CONFIG_PATH) -> None:
 def load_config(path: Path = CONFIG_PATH) -> LoginConfig:
     with open(path, "r") as f:
         raw = json.load(f)
-    return LoginConfig(**raw)
+    return LoginConfig(**raw)

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0/src/lr_gladiator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-gladiator
-Version: 0.5.0
+Version: 0.7.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

{lr_gladiator-0.5.0 → lr_gladiator-0.7.0}/tests/test_smoke.py

@@ -1,6 +1,7 @@
 from gladiator.config import LoginConfig
 from gladiator.arena import ArenaClient
 
+
 def test_client_instantiates():
     cfg = LoginConfig(arena_subdomain="dummy", api_key="x")
     ArenaClient(cfg)