feat: Enhancements/clob

cwmscli/__main__.py

@@ -85,6 +85,7 @@ def cli(
 cli.add_command(commands_cwms.csv2cwms_cmd)
 cli.add_command(commands_cwms.update_cli_cmd)
 cli.add_command(commands_cwms.blob_group)
+cli.add_command(commands_cwms.clob_group)
 cli.add_command(commands_cwms.users_group)
 cli.add_command(load.load_group)
 add_version_to_help_tree(cli)

cwmscli/commands/blob.py

@@ -722,4 +722,12 @@ def list_cmd(
     else:
         # Friendly console preview
         with pd.option_context("display.max_rows", 500, "display.max_columns", None):
-            logging.info(df.to_string(index=False))
+            # Left-align all columns
+            logging.info(
+                "\n"
+                + df.apply(
+                    lambda s: (s := s.astype(str).str.strip()).str.ljust(
+                        s.str.len().max()
+                    )
+                ).to_string(index=False, justify="left")
+            )

cwmscli/commands/clob.py

@@ -0,0 +1,340 @@
+import json
+import logging
+import os
+import sys
+from typing import Optional, Sequence
+
+import cwms
+import pandas as pd
+import requests
+from cwms import api as cwms_api
+
+from cwmscli.utils import get_api_key, has_invalid_chars, log_scoped_read_hint
+
+
+def _join_api_url(api_root: str, path: str) -> str:
+    return f"{api_root.rstrip('/')}/{path.lstrip('/')}"
+
+
+def _resolve_optional_api_key(api_key: Optional[str], anonymous: bool) -> Optional[str]:
+    if anonymous or not api_key:
+        return None
+    return get_api_key(api_key, None)
+
+
+def _write_clob_content(content: str, dest: str) -> str:
+    os.makedirs(os.path.dirname(dest) or ".", exist_ok=True)
+    with open(dest, "w", encoding="utf-8", newline="") as f:
+        f.write(content)
+    return dest
+
+
+def _clob_endpoint_id(clob_id: str) -> tuple[str, Optional[str]]:
+    normalized = clob_id.upper()
+    if has_invalid_chars(normalized):
+        return "ignored", normalized
+    return normalized, None
+
+
+def _get_special_clob_text(*, office: str, clob_id: str) -> str:
+    with cwms_api.SESSION.get(
+        "clobs/ignored",
+        params={"office": office, "clob-id": clob_id},
+        headers={"Accept": "text/plain"},
+    ) as response:
+        response.raise_for_status()
+        return response.text
+
+
+def list_clobs(
+    office: Optional[str] = None,
+    clob_id_like: Optional[str] = None,
+    columns: Optional[Sequence[str]] = None,
+    sort_by: Optional[Sequence[str]] = None,
+    ascending: bool = True,
+    limit: Optional[int] = None,
+    page_size: Optional[int] = None,
+) -> pd.DataFrame:
+    logging.info(f"Listing clobs for office: {office!r}...")
+    fetch_page_size = page_size if page_size is not None else limit
+    result = cwms.get_clobs(
+        office_id=office,
+        clob_id_like=clob_id_like,
+        page_size=fetch_page_size,
+    )
+
+    # Accept either a DataFrame or a JSON/dict-like response
+    if isinstance(result, pd.DataFrame):
+        df = result.copy()
+    else:
+        # Expecting normal clob return structure
+        data = getattr(result, "json", None)
+        if callable(data):
+            data = result.json()
+        df = pd.DataFrame((data or {}).get("clobs", []))
+
+    # Allow column filtering
+    if columns:
+        keep = [c for c in columns if c in df.columns]
+        if keep:
+            df = df[keep]
+
+    # Sort by option
+    if sort_by:
+        by = [c for c in sort_by if c in df.columns]
+        if by:
+            df = df.sort_values(by=by, ascending=ascending, kind="stable")
+
+    # Optional limit
+    if limit is not None:
+        df = df.head(limit)
+
+    logging.info(f"Found {len(df):,} clob(s)")
+    # List the clobs in the logger
+    for _, row in df.iterrows():
+        logging.info(f"clob ID: {row['id']}, Description: {row.get('description')}")
+    return df
+
+
+def upload_cmd(
+    input_file: str,
+    clob_id: str,
+    description: str,
+    overwrite: bool,
+    dry_run: bool,
+    office: str,
+    api_root: str,
+    api_key: str,
+):
+    cwms.init_session(api_root=api_root, api_key=get_api_key(api_key, None))
+    try:
+        file_size = os.path.getsize(input_file)
+        with open(input_file, "r", encoding="utf-8") as f:
+            file_data = f.read()
+        logging.info(f"Read file: {input_file} ({file_size} bytes)")
+    except Exception as e:
+        logging.error(f"Failed to read file: {e}")
+        sys.exit(1)
+
+    clob_id_up = clob_id.upper()
+    logging.debug(f"Office={office} clobID={clob_id_up}")
+
+    clob = {
+        "office-id": office,
+        "id": clob_id_up,
+        "description": (
+            json.dumps(description)
+            if isinstance(description, (dict, list))
+            else description
+        ),
+        "value": file_data,
+    }
+    params = {"fail-if-exists": not overwrite}
+    view_url = _join_api_url(api_root, f"clobs/{clob_id_up}?office={office}")
+
+    if dry_run:
+        logging.info(
+            f"DRY RUN: would POST {_join_api_url(api_root, 'clobs')} with params={params}"
+        )
+        logging.info(
+            json.dumps(
+                {
+                    "url": _join_api_url(api_root, "clobs"),
+                    "params": params,
+                    "clob": {**clob, "value": f'<{len(clob["value"])} chars>'},
+                },
+                indent=2,
+            )
+        )
+        return
+
+    try:
+        cwms.store_clobs(clob, fail_if_exists=not overwrite)
+        logging.info(f"Uploaded clob: {clob_id_up}")
+        if has_invalid_chars(clob_id_up):
+            logging.info(
+                f"View: {_join_api_url(api_root, f'clobs/ignored?clob-id={clob_id_up}&office={office}')}"
+            )
+        else:
+            logging.info(f"View: {view_url}")
+    except requests.HTTPError as e:
+        detail = getattr(e.response, "text", "") or str(e)
+        logging.error(f"Failed to upload (HTTP): {detail}")
+        sys.exit(1)
+    except Exception as e:
+        logging.error(f"Failed to upload: {e}")
+        sys.exit(1)
+
+
+def download_cmd(
+    clob_id: str,
+    dest: str,
+    office: str,
+    api_root: str,
+    api_key: str,
+    dry_run: bool,
+    anonymous: bool = False,
+):
+    if dry_run:
+        logging.info(
+            f"DRY RUN: would GET {api_root} clob with clob-id={clob_id} office={office}."
+        )
+        return
+    resolved_api_key = _resolve_optional_api_key(api_key, anonymous)
+    cwms.init_session(api_root=api_root, api_key=resolved_api_key)
+    bid = clob_id.upper()
+    logging.debug(f"Office={office} clobID={bid}")
+
+    try:
+        path_id, query_id = _clob_endpoint_id(bid)
+        if query_id is None:
+            clob = cwms.get_clob(office_id=office, clob_id=path_id)
+            payload = getattr(clob, "json", clob)
+            if callable(payload):
+                payload = payload()
+            if isinstance(payload, dict):
+                content = payload.get("value", "")
+            else:
+                content = str(payload)
+        else:
+            content = _get_special_clob_text(office=office, clob_id=query_id)
+        target = dest or bid
+        _write_clob_content(content, target)
+        logging.info(f"Downloaded clob to: {target}")
+    except requests.HTTPError as e:
+        detail = getattr(e.response, "text", "") or str(e)
+        logging.error(f"Failed to download (HTTP): {detail}")
+        log_scoped_read_hint(
+            api_key=resolved_api_key,
+            anonymous=anonymous,
+            office=office,
+            action="download",
+            resource="clob content",
+        )
+        sys.exit(1)
+    except Exception as e:
+        logging.error(f"Failed to download: {e}")
+        log_scoped_read_hint(
+            api_key=resolved_api_key,
+            anonymous=anonymous,
+            office=office,
+            action="download",
+            resource="clob content",
+        )
+        sys.exit(1)
+
+
+def delete_cmd(clob_id: str, office: str, api_root: str, api_key: str, dry_run: bool):
+
+    if dry_run:
+        logging.info(
+            f"DRY RUN: would DELETE {api_root} clob with clob-id={clob_id} office={office}"
+        )
+        return
+    cwms.init_session(api_root=api_root, api_key=get_api_key(api_key, None))
+    cid = clob_id.upper()
+    path_id, query_id = _clob_endpoint_id(cid)
+    if query_id is None:
+        cwms.delete_clob(office_id=office, clob_id=cid)
+    else:
+        cwms_api.delete(
+            f"clobs/{path_id}", params={"office": office, "clob-id": query_id}
+        )
+    logging.info(f"Deleted clob: {clob_id} for office: {office}")
+
+
+def update_cmd(
+    input_file: str,
+    clob_id: str,
+    description: str,
+    ignore_nulls: bool,
+    dry_run: bool,
+    office: str,
+    api_root: str,
+    api_key: str,
+):
+    if dry_run:
+        logging.info(
+            f"DRY RUN: would PATCH {api_root} clob with clob-id={clob_id} office={office}"
+        )
+        return
+    file_data = None
+    if input_file:
+        try:
+            file_size = os.path.getsize(input_file)
+            with open(input_file, "r", encoding="utf-8") as f:
+                file_data = f.read()
+            logging.info(f"Read file: {input_file} ({file_size} bytes)")
+        except Exception as e:
+            logging.error(f"Failed to read file: {e}")
+            sys.exit(1)
+    # Setup minimum required payload
+    clob = {"office-id": office, "id": clob_id.upper()}
+    if description:
+        clob["description"] = description
+
+    if file_data:
+        clob["value"] = file_data
+    cwms.init_session(api_root=api_root, api_key=get_api_key(api_key, None))
+    cid = clob_id.upper()
+    path_id, query_id = _clob_endpoint_id(cid)
+    if query_id is None:
+        cwms.update_clob(clob, cid, ignore_nulls=ignore_nulls)
+    else:
+        cwms_api.patch(
+            f"clobs/{path_id}",
+            data=clob,
+            params={"clob-id": query_id, "ignore-nulls": ignore_nulls},
+        )
+    logging.info(f"Updated clob: {clob_id} for office: {office}")
+
+
+def list_cmd(
+    clob_id_like: str,
+    columns: list[str],
+    sort_by: list[str],
+    desc: bool,
+    limit: int,
+    page_size: int,
+    to_csv: str,
+    office: str,
+    api_root: str,
+    api_key: str,
+    anonymous: bool = False,
+):
+    resolved_api_key = _resolve_optional_api_key(api_key, anonymous)
+    cwms.init_session(api_root=api_root, api_key=resolved_api_key)
+    try:
+        df = list_clobs(
+            office=office,
+            clob_id_like=clob_id_like,
+            columns=columns,
+            sort_by=sort_by,
+            ascending=not desc,
+            limit=limit,
+            page_size=page_size,
+        )
+    except Exception:
+        log_scoped_read_hint(
+            api_key=resolved_api_key,
+            anonymous=anonymous,
+            office=office,
+            action="list",
+            resource="clob content",
+        )
+        raise
+    if to_csv:
+        df.to_csv(to_csv, index=False)
+        logging.info(f"Wrote {len(df)} rows to {to_csv}")
+    else:
+        # Friendly console preview
+        with pd.option_context("display.max_rows", 500, "display.max_columns", None):
+            # Left-align all columns
+            logging.info(
+                "\n"
+                + df.apply(
+                    lambda s: (s := s.astype(str).str.strip()).str.ljust(
+                        s.str.len().max()
+                    )
+                ).to_string(index=False, justify="left")
+            )