cwms-cli 0.3.7__tar.gz → 0.4.0__tar.gz

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwms-cli
-Version: 0.3.7
+Version: 0.4.0
 Summary: Command line utilities for Corps Water Management Systems (CWMS) python scripts. This is a collection of shared scripts across the enterprise Water Management Enterprise System (WMES) teams.
 License: LICENSE
 License-File: LICENSE

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/__main__.py

@@ -85,6 +85,7 @@ cli.add_command(commands_cwms.shefcritimport)
 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.users_group)
 cli.add_command(load.load_group)
 add_version_to_help_tree(cli)
 

cwms_cli-0.4.0/cwmscli/callbacks/__init__.py

@@ -0,0 +1,27 @@
+# Click callbacks for click
+
+import re
+
+
+def csv_to_list(ctx, param, value):
+    """Accept multiple values either via repeated flags or a single delimiter-separated string.
+
+    Supported delimiters are comma (,) and pipe (|) to make CLI usage easier and avoid
+    shell pipe interpretation issues when users type role shortcuts.
+    """
+    if value is None:
+        return None
+    if isinstance(value, (list, tuple)):
+        out = []
+        for v in value:
+            if isinstance(v, str) and ("," in v or "|" in v):
+                for part in re.split(r"[,|]", v):
+                    part = part.strip()
+                    if part:
+                        out.append(part)
+            else:
+                out.append(v)
+        return tuple(out)
+    if isinstance(value, str):
+        return tuple(p.strip() for p in re.split(r"[,|]", value) if p.strip())
+    return value

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/commands/commands_cwms.py

@@ -9,7 +9,17 @@ import click
 from cwmscli import requirements as reqs
 from cwmscli.callbacks import csv_to_list
 from cwmscli.commands import csv2cwms
-from cwmscli.utils import api_key_loc_option, colors, common_api_options, to_uppercase
+from cwmscli.utils import (
+    api_key_loc_option,
+    api_key_option,
+    api_root_option,
+    colors,
+    common_api_options,
+    get_api_key,
+    office_option,
+    office_option_notrequired,
+    to_uppercase,
+)
 from cwmscli.utils.deps import requires
 from cwmscli.utils.update import (
     build_update_package_spec,
@@ -393,3 +403,146 @@ def list_cmd(**kwargs):
     from cwmscli.commands.blob import list_cmd
 
     list_cmd(**kwargs)
+
+
+# ================================================================================
+#       USERS
+# ================================================================================
+user_name_option = click.option(
+    "-u",
+    "--user-name",
+    type=str,
+    default=None,
+    required=True,
+    help="Existing user name.",
+)
+
+
+@click.group(
+    "users",
+    help="Manage CWMS users and user-management roles",
+)
+def users_group():
+    pass
+
+
+@users_group.command(
+    "user-ids",
+    help="List all available user IDs for an office or lookup using like filter",
+)
+@office_option_notrequired
+@api_root_option
+@api_key_option
+@api_key_loc_option
+@click.option(
+    "-ul",
+    "--username-like",
+    type=str,
+    default=None,
+    help="Enter any part of a user name to filter user id listing. Case-insensitive.",
+)
+@requires(reqs.cwms)
+def users_user_ids(office, api_root, api_key, api_key_loc, username_like):
+    from cwmscli.commands.users import list_user_ids
+
+    list_user_ids(
+        office=office,
+        api_root=api_root,
+        api_key=api_key,
+        api_key_loc=api_key_loc,
+        username_like=username_like,
+    )
+
+
+@click.group(
+    "roles",
+    help="Manage CWMS users and user-management roles",
+)
+def roles_group():
+    pass
+
+
+@roles_group.command(
+    "list-all",
+    help="List assignable CWMS user-management roles",
+)
+@api_root_option
+@api_key_option
+@api_key_loc_option
+@requires(reqs.cwms)
+def users_roles_list_all(api_root, api_key, api_key_loc):
+    from cwmscli.commands.users import list_roles
+
+    list_roles(api_root=api_root, api_key=api_key, api_key_loc=api_key_loc)
+
+
+@roles_group.command("list-user", help="List roles for a specific user and office")
+@user_name_option
+@office_option_notrequired
+@api_root_option
+@api_key_option
+@api_key_loc_option
+@requires(reqs.cwms)
+def users_roles_list_user(user_name, office, api_root, api_key, api_key_loc):
+    from cwmscli.commands.users import list_user_roles
+
+    list_user_roles(
+        user_name=user_name,
+        office=office,
+        api_root=api_root,
+        api_key=api_key,
+        api_key_loc=api_key_loc,
+    )
+
+
+@roles_group.command("add", help="Add one or more roles to an existing user")
+@common_api_options
+@api_key_loc_option
+@user_name_option
+@click.option(
+    "--roles",
+    multiple=True,
+    default=None,
+    callback=csv_to_list,
+    help="enter admin, readonly, readwrite, or individual role name(s) to add. Repeat the option or pass a comma/pipe-separated list.",
+)
+@requires(reqs.cwms)
+def users_roles_add(office, api_root, api_key, api_key_loc, user_name, roles):
+    from cwmscli.commands.users import add_roles
+
+    add_roles(
+        user_name=user_name,
+        roles=roles,
+        office=office,
+        api_root=api_root,
+        api_key=api_key,
+        api_key_loc=api_key_loc,
+    )
+
+
+@roles_group.command("delete", help="Remove one or more roles from an existing user")
+@common_api_options
+@api_key_loc_option
+@user_name_option
+@click.option(
+    "--roles",
+    multiple=True,
+    default=None,
+    callback=csv_to_list,
+    help="enter 'all' to delete all roles, or admin, readonly, readwrite, or individual role name(s) to delete. Repeat the option or pass a comma/pipe-separated list.",
+)
+@requires(reqs.cwms)
+def users_roles_delete(office, api_root, api_key, api_key_loc, user_name, roles):
+    from cwmscli.commands.users import delete_roles
+
+    delete_roles(
+        user_name=user_name,
+        roles=roles,
+        office=office,
+        api_root=api_root,
+        api_key=api_key,
+        api_key_loc=api_key_loc,
+    )
+
+
+users_group.add_command(roles_group)

cwms_cli-0.4.0/cwmscli/commands/users.py

@@ -0,0 +1,420 @@
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import click
+
+from cwmscli.utils import colors, get_api_key
+
+
+def _format_table(headers: list[str], rows: list[list[str]]) -> str:
+    widths = [len(header) for header in headers]
+    for row in rows:
+        for idx, cell in enumerate(row):
+            widths[idx] = max(widths[idx], len(cell))
+
+    def render_row(row: list[str]) -> str:
+        return "  ".join(cell.ljust(widths[idx]) for idx, cell in enumerate(row))
+
+    divider = "  ".join("-" * width for width in widths)
+    lines = [render_row(headers), divider]
+    lines.extend(render_row(row) for row in rows)
+    return "\n".join(lines)
+
+
+def _cmd(text: str) -> str:
+    return colors.c(text, "blue", bright=True)
+
+
+def _format_api_error(error: Exception, cwms_module) -> str:
+    message = str(error)
+    if isinstance(error, cwms_module.api.PermissionError):
+        status_text = "CDA responded with 403 Forbidden."
+        if status_text in message:
+            message = message.replace(status_text, colors.err(status_text))
+        message = (
+            f"{message} Use an admin API key or sign in as a user with user-management "
+            "admin roles. I.e. 'CWMS User Admins'"
+        )
+    return message
+
+
+def _handle_api_error(error: Exception, cwms_module) -> None:
+    raise click.ClickException(_format_api_error(error, cwms_module)) from None
+
+
+def _init_cwms(api_root: str, api_key: str, api_key_loc: str) -> object:
+    import cwms
+
+    resolved_api_key = get_api_key(api_key, api_key_loc)
+    cwms.init_session(api_root=api_root, api_key=resolved_api_key)
+    return cwms
+
+
+def _fetch_roles(cwms_module) -> list[str]:
+    try:
+        return sorted(cwms_module.get_roles(), key=str.casefold)
+    except cwms_module.api.ApiError as error:
+        _handle_api_error(error, cwms_module)
+
+
+def _fetch_users(
+    cwms_module, office=None, username_like=None, page_size: int = 5000
+) -> list[dict]:
+    users: list[dict] = []
+
+    try:
+        response = cwms_module.get_users(
+            office_id=office, username_like=username_like, page_size=page_size
+        )
+    except cwms_module.api.ApiError as error:
+        _handle_api_error(error, cwms_module)
+
+    payload = getattr(response, "json", {}) or {}
+    page_users = payload.get("users", [])
+    users.extend(page_users)
+
+    return users
+
+
+def _fetch_user_roles(
+    cwms_module, user_name: str, office: Optional[str] = None
+) -> list[str]:
+    roles_payload = _get_user_roles_payload(cwms_module, user_name)
+    return _extract_roles_from_payload(roles_payload, office)
+
+
+def _get_user_roles_payload(cwms_module, user_name: str) -> dict:
+    try:
+        payload = cwms_module.get_user(user_name=user_name)
+        return payload.get("roles", {})
+    except cwms_module.api.ApiError as error:
+        _handle_api_error(error, cwms_module)
+
+
+def _extract_roles_from_payload(
+    roles_payload: dict, office: Optional[str] = None
+) -> list[str]:
+    if isinstance(roles_payload, dict):
+        if office:
+            office_key = office.strip().upper()
+            office_roles = roles_payload.get(office_key, [])
+            if office_roles is None:
+                office_roles = []
+            return [r.strip() for r in office_roles if r and r.strip()]
+        all_roles = []
+        for rlist in roles_payload.values():
+            if rlist:
+                all_roles.extend(rlist)
+        return sorted(
+            {r.strip() for r in all_roles if r and r.strip()}, key=str.casefold
+        )
+
+    if isinstance(roles_payload, list):
+        return [r.strip() for r in roles_payload if r and r.strip()]
+
+    return []
+
+
+def _existing_user_name(users: list[dict], user_name: str) -> Optional[str]:
+
+    requested = user_name.strip().casefold()
+    for user in users:
+        existing = str(user.get("user-name", "")).strip()
+        if existing and existing.casefold() == requested:
+            return existing
+    return None
+
+
+def _split_roles(
+    raw_roles: Optional[Union[tuple[str, ...], list[str]]] = None
+) -> list[str]:
+    if not raw_roles:
+        return []
+    return [role.strip() for role in raw_roles if role and role.strip()]
+
+
+def _expand_role_shortcuts(roles: list[str]) -> list[str]:
+    emap = {
+        "admin": ["All Users", "CWMS Users", "TS ID Creator", "CWMS User Admins"],
+        "readonly": ["All Users", "CWMS Users"],
+        "readwrite": ["All Users", "CWMS Users", "TS ID Creator"],
+    }
+
+    expanded_roles: list[str] = []
+    for role in roles:
+        key = role.strip().casefold()
+        if key == "all":
+            expanded_roles.append(role)  # Keep "all" as is, handled elsewhere
+        elif key in emap:
+            expanded_roles.extend(emap[key])
+        else:
+            expanded_roles.append(role)
+    return expanded_roles
+
+
+def _validate_role_inputs(
+    users: list[dict], available_roles: list[str], user_name: str, roles: list[str]
+) -> tuple[str, list[str]]:
+    existing_user = _existing_user_name(users, user_name)
+    if not existing_user:
+        raise click.ClickException(f"User '{user_name}' was not found in CDA /users.")
+
+    roles_lookup = {role.casefold(): role for role in available_roles}
+    normalized_roles: list[str] = []
+    invalid_roles: list[str] = []
+
+    for role in roles:
+        normalized = roles_lookup.get(role.casefold())
+        if normalized:
+            normalized_roles.append(normalized)
+        else:
+            invalid_roles.append(role)
+
+    if invalid_roles:
+        invalid = ", ".join(colors.err(role) for role in invalid_roles)
+        raise click.ClickException(
+            f"Unknown role value(s): {invalid}. Run {_cmd('cwms-cli users roles')} to see the valid role catalog."
+        )
+
+    deduped_roles = []
+    seen_roles = set()
+    for role in normalized_roles:
+        if role not in seen_roles:
+            seen_roles.add(role)
+            deduped_roles.append(role)
+
+    if not deduped_roles:
+        raise click.ClickException("At least one valid role is required.")
+
+    return existing_user, deduped_roles
+
+
+def _render_roles_table(roles: list[str]) -> str:
+    rows = [[colors.c(role, "green")] for role in roles]
+    return _format_table(["Role"], rows)
+
+
+def _render_user_roles_table(user_roles: dict[str, list[str]]) -> str:
+    rows = []
+    for office, roles in sorted(user_roles.items()):
+        roles_str = ", ".join(sorted(roles))
+        rows.append([colors.c(office, "cyan"), colors.c(roles_str, "green")])
+    return _format_table(["Office", "Roles"], rows)
+
+
+def _render_users_table(users: list[dict]) -> str:
+    rows = [[colors.c(user.get("user-name", ""), "green")] for user in users]
+    return _format_table(["User Name"], rows)
+
+
+def _prompt_for_role_inputs(
+    action: str, available_roles: list[str]
+) -> tuple[str, list[str]]:
+    click.echo(f"Enter the target user and one or more roles to {action}.")
+    click.echo("")
+    user_name = click.prompt("User name", type=str).strip()
+    click.echo("")
+    click.echo("Available roles:")
+    click.echo(_render_roles_table(available_roles))
+    click.echo("")
+    roles_raw = click.prompt(
+        "Roles (comma-separated; use names exactly as listed; or shortcuts admin/readwrite/readonly)",
+        type=str,
+    ).strip()
+    roles = [role.strip() for role in roles_raw.split(",") if role.strip()]
+    return user_name, roles
+
+
+def _prompt_for_office(office: str) -> str:
+    colored_office = colors.c(office, "cyan", bright=True)
+    change_office = click.confirm(
+        f"You have office set to {colored_office}, would you like to change this?",
+        default=False,
+    )
+    if not change_office:
+        return office
+
+    return (
+        click.prompt("Office", type=str, default=office, show_default=True)
+        .strip()
+        .upper()
+    )
+
+
+def list_roles(api_root: str, api_key: str, api_key_loc: str) -> None:
+    cwms = _init_cwms(api_root, api_key, api_key_loc)
+    roles = _fetch_roles(cwms)
+    header_count = colors.c(str(len(roles)), "cyan", bright=True)
+    click.echo(f"Available roles for user management: {header_count}")
+    if not roles:
+        click.echo(colors.warn("No roles were returned."))
+        return
+    click.echo(_render_roles_table(roles))
+
+
+def list_user_roles(
+    user_name: str, office: Optional[str], api_root: str, api_key: str, api_key_loc: str
+) -> None:
+    cwms = _init_cwms(api_root, api_key, api_key_loc)
+    roles_payload = _get_user_roles_payload(cwms, user_name)
+    if isinstance(roles_payload, dict):
+        if office:
+            office_key = office.strip().upper()
+            office_roles = roles_payload.get(office_key, [])
+            if office_roles is None:
+                office_roles = []
+            user_roles = [r.strip() for r in office_roles if r and r.strip()]
+            header = (
+                f"Roles for user '{user_name}' in office '{office}': {len(user_roles)}"
+            )
+            click.echo(colors.c(header, "cyan", bright=True))
+            if not user_roles:
+                click.echo(colors.warn("No roles found."))
+                return
+            click.echo(_render_roles_table(user_roles))
+        else:
+            # List roles for each office
+            header = f"Roles for user '{user_name}' across all offices:"
+            click.echo(colors.c(header, "cyan", bright=True))
+            for off, roles in roles_payload.items():
+                if roles:
+                    cleaned_roles = [r.strip() for r in roles if r and r.strip()]
+                    if cleaned_roles:
+                        click.echo(
+                            colors.c(
+                                f"Office '{off}': {len(cleaned_roles)} roles", "yellow"
+                            )
+                        )
+                        click.echo(_render_roles_table(cleaned_roles))
+                        click.echo("")
+                else:
+                    click.echo(colors.c(f"Office '{off}': No roles", "yellow"))
+                    click.echo("")
+    else:
+        click.echo(colors.warn("Unexpected roles format."))
+
+
+def list_user_ids(
+    office: str,
+    api_root: str,
+    api_key: str,
+    api_key_loc: str,
+    username_like: Optional[str] = None,
+) -> None:
+    # This command is wired from user roles group default action. Users can
+    # pass an optional name filter but for now roles view is what should be shown.
+    cwms = _init_cwms(api_root, api_key, api_key_loc)
+    users = _fetch_users(cwms, office, username_like=username_like)
+    click.echo(_render_users_table(users))
+
+
+def add_roles(
+    office: str,
+    api_root: str,
+    api_key: str,
+    api_key_loc: str,
+    user_name: Optional[str],
+    roles: Optional[Union[tuple[str, ...], list[str]]],
+) -> None:
+    provided_user_name = (user_name or "").strip()
+    provided_roles = _split_roles(roles)
+
+    if bool(provided_user_name) ^ bool(provided_roles):
+        raise click.ClickException(
+            "Either specify all add arguments (--user-name and --roles) or run "
+            f"{_cmd('cwms-cli users roles add')} interactively with no add-specific args."
+        )
+
+    cwms = _init_cwms(api_root, api_key, api_key_loc)
+    users = _fetch_users(cwms)
+    available_roles = _fetch_roles(cwms)
+
+    if not provided_user_name and not provided_roles:
+        office = _prompt_for_office(office)
+        provided_user_name, provided_roles = _prompt_for_role_inputs(
+            "add", available_roles
+        )
+
+    provided_roles = _expand_role_shortcuts(provided_roles)
+    existing_user, validated_roles = _validate_role_inputs(
+        users, available_roles, provided_user_name, provided_roles
+    )
+
+    try:
+        cwms.store_user(
+            user_name=existing_user, office_id=office, roles=validated_roles
+        )
+    except cwms.api.ApiError as error:
+        _handle_api_error(error, cwms)
+
+    click.echo(
+        f"Added {len(validated_roles)} role(s) to user "
+        f"{colors.c(existing_user, 'cyan', bright=True)} for office "
+        f"{colors.c(office, 'cyan', bright=True)}."
+    )
+    click.echo(_render_roles_table(validated_roles))
+
+
+def delete_roles(
+    office: str,
+    api_root: str,
+    api_key: str,
+    api_key_loc: str,
+    user_name: Optional[str],
+    roles: Optional[Union[tuple[str, ...], list[str]]],
+) -> None:
+    provided_user_name = (user_name or "").strip()
+    provided_roles = _split_roles(roles)
+    provided_roles = _expand_role_shortcuts(provided_roles)
+
+    if bool(provided_user_name) ^ bool(provided_roles):
+        raise click.ClickException(
+            "Either specify all delete arguments (--user-name and --roles) or run "
+            f"{_cmd('cwms-cli users roles delete')} interactively with no delete-specific args."
+        )
+
+    cwms = _init_cwms(api_root, api_key, api_key_loc)
+    users = _fetch_users(cwms, office)
+    available_roles = _fetch_roles(cwms)
+
+    if not provided_user_name and not provided_roles:
+        office = _prompt_for_office(office)
+        provided_user_name, provided_roles = _prompt_for_role_inputs(
+            "delete", available_roles
+        )
+        provided_roles = _expand_role_shortcuts(provided_roles)
+
+    if provided_roles and any(r.strip().casefold() == "all" for r in provided_roles):
+        if len(provided_roles) > 1:
+            raise click.ClickException("'all' cannot be specified with other roles.")
+        existing_user = _existing_user_name(users, provided_user_name)
+        if not existing_user:
+            raise click.ClickException(f"User '{provided_user_name}' not found.")
+        fetched_roles = _fetch_user_roles(cwms, existing_user, office)
+        provided_roles = fetched_roles
+
+    existing_user, validated_roles = _validate_role_inputs(
+        users, available_roles, provided_user_name, provided_roles
+    )
+    if "All Users" in validated_roles:
+        validated_roles.remove("All Users")
+        click.echo(
+            colors.warn(
+                "Warning: 'All Users' role cannot be deleted directly and will remain assigned. "
+                "Any other specified roles will be deleted as requested."
+            )
+        )
+    try:
+        cwms.delete_user_roles(
+            user_name=existing_user, office_id=office, roles=validated_roles
+        )
+    except cwms.api.ApiError as error:
+        _handle_api_error(error, cwms)
+
+    click.echo(
+        f"Deleted {len(validated_roles)} role(s) from user "
+        f"{colors.c(existing_user, 'cyan', bright=True)} for office "
+        f"{colors.c(office, 'cyan', bright=True)}."
+    )
+    click.echo(_render_roles_table(validated_roles))

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/requirements.py

@@ -5,7 +5,7 @@
 cwms = {
     "module": "cwms",
     "package": "cwms-python",
-    "version": "0.8.0",
+    "version": "1.0.7",
     "desc": "CWMS REST API Python client",
     "link": "https://github.com/HydrologicEngineeringCenter/cwms-python",
 }

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/usgs/getusgs_cda.py

@@ -6,6 +6,36 @@ import numpy as np
 import pandas as pd
 import requests
 
+from cwmscli.utils import colors
+
+
+def _log_error_and_exit(message: str, hint: str | None = None, *, exit_code: int = 1):
+    logging.error(colors.c(message, "red", bright=True))
+    if hint:
+        logging.error(colors.c(f"Hint: {hint}", "yellow", bright=True))
+    raise SystemExit(exit_code)
+
+
+def _require_group_dataframe(response, *, resource_name: str, office: str):
+    payload = getattr(response, "json", None)
+
+    try:
+        df = response.df
+    except AttributeError as exc:
+        if isinstance(payload, str):
+            _log_error_and_exit(
+                f"CWMS returned an unexpected response while reading {resource_name} for office {office}.",
+                "Check that --api-root points to the CDA API endpoint ending in /cwms-data.",
+            )
+        raise
+
+    if df is None:
+        _log_error_and_exit(
+            f"CWMS did not return any {resource_name} data for office {office}."
+        )
+
+    return df
+
 
 def getusgs_cda(
     api_root: str,
@@ -58,12 +88,13 @@ def getusgs_cda(
         CWMS_writeData(USGS_ts, USGS_data, USGS_data_method, days_back)
     else:
         if backfill_tsids:
-            logging.error(
-                f"The following backload timeseries ids were not present in the USGS timeseries or Locations groups: {backfill_tsids}"
+            _log_error_and_exit(
+                f"The following backfill time series ids were not present in the USGS time series or location alias groups: {backfill_tsids}"
             )
         else:
-            logging.error(
-                f"USGS data was present in the timeseries or locations groups"
+            _log_error_and_exit(
+                f"No eligible USGS time series were found for office {office_id}.",
+                "Confirm that time series exist in Data Acquisition / USGS TS Data Acquisition and that matching entries exist in Agency Aliases / USGS Station Number.",
             )
 
 
@@ -115,18 +146,36 @@ def get_CMWS_TS_Loc_Data(office):
             usgs_param = "Not Found"
         return usgs_param
 
-    df = cwms.get_timeseries_group(
-        group_id="USGS TS Data Acquisition",
-        category_id="Data Acquisition",
-        office_id=office,
-        category_office_id="CWMS",
-        group_office_id="CWMS",
-    ).df
+    df = _require_group_dataframe(
+        cwms.get_timeseries_group(
+            group_id="USGS TS Data Acquisition",
+            category_id="Data Acquisition",
+            office_id=office,
+            category_office_id="CWMS",
+            group_office_id="CWMS",
+        ),
+        resource_name="USGS TS Data Acquisition group",
+        office=office,
+    )
+    if df is None or df.empty:
+        _log_error_and_exit(
+            f"No time series are defined in Data Acquisition / USGS TS Data Acquisition for office {office}.",
+            "Add one or more time series to that group, then rerun the command.",
+        )
+    if "timeseries-id" not in df.columns:
+        _log_error_and_exit(
+            "The USGS TS Data Acquisition group response did not include a 'timeseries-id' column."
+        )
     df[["location-id", "param", "type", "int", "dur", "ver"]] = df[
         "timeseries-id"
     ].str.split(".", expand=True)
 
     df = df[df["office-id"] == office]
+    if df.empty:
+        _log_error_and_exit(
+            f"No time series are defined in Data Acquisition / USGS TS Data Acquisition for office {office}.",
+            "Add one or more office-specific time series to that group, then rerun the command.",
+        )
     df["base-loc"] = df["location-id"].str.split("-", expand=True)[0]
     if "alias-id" not in df.columns:
         df["alias-id"] = np.nan
@@ -135,17 +184,31 @@ def get_CMWS_TS_Loc_Data(office):
     df = df.rename(columns={"alias-id": "USGS_Method_TS"})
 
     # error in CDA with category_office_id and group_office_id. need to fix once CDA is updated
-    Locdf = cwms.get_location_group(
-        loc_group_id="USGS Station Number",
-        category_id="Agency Aliases",
-        office_id="CWMS",
-    ).df.set_index("location-id")
+    Locdf = _require_group_dataframe(
+        cwms.get_location_group(
+            loc_group_id="USGS Station Number",
+            category_id="Agency Aliases",
+            office_id="CWMS",
+        ),
+        resource_name="USGS Station Number alias group",
+        office=office,
+    ).set_index("location-id")
 
     Locdf = Locdf[Locdf["office-id"] == office]
+    if Locdf.empty:
+        _log_error_and_exit(
+            f"No USGS location aliases are defined in Agency Aliases / USGS Station Number for office {office}.",
+            "Add one or more location aliases to that group, then rerun the command.",
+        )
     if "attribute" not in Locdf.columns:
         Locdf["attribute"] = np.nan
     # Grab all of the locations that have a USGS station number assigned to them
     USGS_alias = Locdf[Locdf["alias-id"].notnull()]
+    if USGS_alias.empty:
+        _log_error_and_exit(
+            f"No USGS location aliases are defined in Agency Aliases / USGS Station Number for office {office}.",
+            "Add one or more alias-id values for that office, then rerun the command.",
+        )
     # rename the columns
     USGS_alias = USGS_alias.rename(
         columns={"alias-id": "USGS_St_Num", "attribute": "Loc_attribute"}

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/utils/__init__.py

@@ -42,6 +42,16 @@ office_option = click.option(
     callback=to_uppercase,
     help="Office to grab data for",
 )
+office_option_notrequired = click.option(
+    "-o",
+    "--office",
+    default=None,
+    required=False,
+    envvar="OFFICE",
+    type=str,
+    callback=to_uppercase,
+    help="Office to grab data for",
+)
 api_root_option = click.option(
     "-a",
     "--api-root",
@@ -82,17 +92,18 @@ log_level_option = click.option(
     envvar="LOG_LEVEL",
     callback=_set_log_level,
     expose_value=False,  # Callback will set the log level of all methods
-    is_eager=True,  # Run before other commands (to cover any logging statements)
+    # Run before other commands (to cover any logging statements)
+    is_eager=True,
     help="Set logging verbosity (overrides default INFO).",
 )
 
 
 def get_api_key(api_key: str, api_key_loc: str) -> str:
-    if api_key is not None:
-        return api_key
-    elif api_key_loc is not None:
+    if api_key_loc is not None:
         with open(api_key_loc, "r") as f:
             return f.readline().strip()
+    elif api_key is not None:
+        return api_key
     else:
         raise Exception(
             "must add a value to either --api-key(-k) or --api-key-loc(-kl)"

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/utils/click_help.py

@@ -41,6 +41,9 @@ def _docs_url_for_context(ctx: click.Context) -> Optional[str]:
     command = (ctx.info_name or getattr(ctx.command, "name", None) or "").strip()
     page_map = {
         "blob": "blob",
+        "update": "update",
+        "users": "users",
+        "version": "version",
     }
     # Link to dedicated pages that are created in \docs
     if command in page_map:

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/utils/colors.py

@@ -17,8 +17,6 @@ def c(text: str, color: str, bright: bool = False) -> str:
     # Find the color in Fore and apply it to the text, then reset the style at the end
     if hasattr(Fore, color.upper()):
         color = getattr(Fore, color.upper())
-    else:
-        color = ""
     return f"{color}{b}{text}{Style.RESET_ALL}"
 
 

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/cwmscli/utils/deps.py

@@ -40,7 +40,7 @@ def requires(*requirements):
             {
                 "module": "cwms",
                 "package": "cwms-python",
-                "version": "0.8.0",
+                "version": "1.0.3",
                 "desc": "CWMS REST API Python client",
                 "link": "https://github.com/hydrologicengineeringcenter/cwms-python"
             },

{cwms_cli-0.3.7 → cwms_cli-0.4.0}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "cwms-cli"
 repository = "https://github.com/HydrologicEngineeringCenter/cwms-cli"
 
-version = "0.3.7"
+version = "0.4.0"
 
 
 packages = [
@@ -18,7 +18,7 @@ authors = ["Eric Novotny <eric.v.novotny@usace.army.mil>", "Charles Graham <char
 python = "^3.9"
 click = "^8.1.8"
 hecdss  = { version = ">=0.1.24", optional = true }  # Via https://github.com/HydrologicEngineeringCenter/hec-python-library/blob/main/hec/shared.py#L9-10
-cwms-python = { version = ">=0.8.0", optional = true}
+cwms-python = { version = ">=1.0.7", optional = true}
 colorama = "^0.4.6"
 
 [tool.poetry.group.dev.dependencies]
@@ -30,6 +30,10 @@ pytest = "^8.3.5"
 #pytest-cov = "^4.1.0"
 #pandas-stubs = "^2.2.1.240316"
 yamlfix = "^1.16.0"
+pandas = "^2.1.3"
+cwms-python = "^1.0.7"
+hecdss = "^0.1.24"
+
 
 [build-system]
 requires = ["poetry-core"]

cwms_cli-0.3.7/cwmscli/callbacks/__init__.py

@@ -1,18 +0,0 @@
-# Click callbacks for click
-
-
-def csv_to_list(ctx, param, value):
-    """Accept multiple values either via repeated flags or a single comma-delimited string."""
-    if value is None:
-        return None
-    if isinstance(value, (list, tuple)):
-        out = []
-        for v in value:
-            if isinstance(v, str) and "," in v:
-                out.extend([p.strip() for p in v.split(",") if p.strip()])
-            else:
-                out.append(v)
-        return tuple(out)
-    if isinstance(value, str):
-        return tuple([p.strip() for p in value.split(",") if p.strip()])
-    return value