cwms-cli 0.8.1__tar.gz → 0.9.0__tar.gz

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwms-cli
-Version: 0.8.1
+Version: 0.9.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
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Provides-Extra: dss
 Requires-Dist: click (>=8.1.8,<9.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/cwmscli/commands/commands_cwms.py

@@ -534,15 +534,13 @@ def update_cli_cmd(target_version: Optional[str], pre: bool, yes: bool) -> None:
 @click.group(
     "blob",
     help="Manage CWMS Blobs (upload, download, delete, update, list)",
-    epilog=textwrap.dedent(
-        """
+    epilog=textwrap.dedent("""
     Example Usage:\n
     - Store a PDF/image as a CWMS blob with optional description\n
     - Download a blob by id to your local filesystem\n
     - Update a blob's name/description/mime-type\n
     - Bulk list blobs for an office  
-"""
-    ),
+"""),
 )
 def blob_group():
     pass
@@ -755,14 +753,12 @@ def list_cmd(**kwargs):
 @click.group(
     "clob",
     help="Manage CWMS Clobs (upload, download, delete, update, list)",
-    epilog=textwrap.dedent(
-        """
+    epilog=textwrap.dedent("""
     Example Usage:\n
     - Download a clob by id to your local filesystem\n
     - Update a clob's name/description/mime-type\n
     - Bulk list clobs for an office  
-"""
-    ),
+"""),
 )
 @requires(reqs.cwms)
 def clob_group():
@@ -1017,7 +1013,7 @@ def users_roles_list_user(user_name, office, api_root, api_key, api_key_loc):
     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.",
+    help="enter admin, readonly, readwrite, batchadmin, 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):

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/cwmscli/commands/users.py

@@ -58,11 +58,45 @@ def _fetch_roles(cwms_module) -> list[str]:
         _handle_api_error(error, cwms_module)
 
 
+# Role shortcut expansions used by `_expand_role_shortcuts` and
+# referenced during validation so expanded roles are accepted even when the
+# CWMS role catalog returned by the API does not include all shortcut values.
+ROLE_SHORTCUTS: dict[str, list[str]] = {
+    "admin": [
+        "All Users",
+        "CWMS Users",
+        "TS ID Creator",
+        "CWMS User Admins",
+        "CWMS PD Users",
+        "Data Acquisition Mgr",
+    ],
+    "readonly": ["All Users", "CWMS Users"],
+    "readwrite": ["All Users", "CWMS Users", "TS ID Creator"],
+    "batchadmin": [
+        "All Users",
+        "CWMS Users",
+        "TS ID Creator",
+        "Data Acquisition Mgr",
+    ],
+}
+
+
 def _fetch_users(
     cwms_module, office=None, username_like=None, page_size: int = 5000
 ) -> list[dict]:
     users: list[dict] = []
 
+    # If a username_like filter was provided, ensure it is wrapped with
+    # leading and trailing wildcards so CDA receives a contains-style query.
+    if username_like:
+        _ul = str(username_like).strip()
+        if _ul:
+            if not _ul.startswith("*"):
+                _ul = "*" + _ul
+            if not _ul.endswith("*"):
+                _ul = _ul + "*"
+            username_like = _ul
+
     try:
         response = cwms_module.get_users(
             office_id=office, username_like=username_like, page_size=page_size
@@ -135,19 +169,13 @@ def _split_roles(
 
 
 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])
+        elif key in ROLE_SHORTCUTS:
+            expanded_roles.extend(ROLE_SHORTCUTS[key])
         else:
             expanded_roles.append(role)
     return expanded_roles

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/cwmscli/usgs/getusgs_cda.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from datetime import datetime, timedelta
 from typing import Optional
 
@@ -375,6 +376,35 @@ def CWMS_writeData(USGS_ts, USGS_data, USGS_data_method, days_back):
                         office = row["office-id"]
                         values["quality-code"] = 0
 
+                        # Resample to TSID interval when needed.
+                        values = resample_to_tsid_interval(values, ts_id)
+
+                        # Drop rows with missing values produced by resampling
+                        # (CWMS CDA rejects NaN/Na values in the values array).
+                        try:
+                            n_before = len(values)
+                            values = values.dropna(subset=["value"]).copy()
+                            n_after = len(values)
+                            if n_after != n_before:
+                                logging.info(
+                                    f"Dropped {n_before - n_after} rows with missing values for {ts_id} after resampling"
+                                )
+                        except Exception:
+                            # If anything goes wrong, continue and let the store call fail
+                            # so the caller sees the original error.
+                            pass
+
+                        # Ensure quality-code is numeric and has no NaN entries.
+                        if "quality-code" in values.columns:
+                            try:
+                                values["quality-code"] = (
+                                    values["quality-code"].fillna(0).astype(int)
+                                )
+                            except Exception:
+                                values["quality-code"] = values["quality-code"].fillna(
+                                    0
+                                )
+
                         # write values to CWMS database
                         try:
                             data = cwms.timeseries_df_to_json(
@@ -422,3 +452,80 @@ def CWMS_writeData(USGS_ts, USGS_data, USGS_data_method, days_back):
     logging.info(
         f"The following ts_ids errored because multiple method TSID were present for the USGS station. A USGS method TSID needs to be defined in the time series group in CWMS or an incorrect TSID is defined. {mult_ids}"
     )
+
+
+def resample_to_tsid_interval(values: pd.DataFrame, ts_id: str) -> pd.DataFrame:
+    """Resample the incoming values DataFrame to the interval encoded in ``ts_id``.
+
+    The DataFrame is expected to have columns ``date-time`` and ``value``. The
+    function returns a new DataFrame with the same columns. If the TSID encodes
+    an irregular interval (contains '~' or '0') the original DataFrame is
+    returned unchanged. Otherwise the function infers the incoming data
+    frequency and resamples only when it differs from the TSID interval.
+    """
+    if values is None or values.empty:
+        return values
+
+    try:
+        interval_segment = ts_id.split(".")[3]
+    except Exception:
+        return values
+
+    if "~" in interval_segment or interval_segment == "0":
+        return values
+
+    m = re.match(r"^(\d+)(.*)", interval_segment)
+    if m:
+        interval_number = int(m.group(1))
+        interval_type = m.group(2)
+    else:
+        return values
+
+    if interval_type == "Minutes":
+        target_str = f"{interval_number}min"
+    else:
+        # use lower-case single-letter codes (pandas prefers lower-case symbols)
+        target_str = f"{interval_number}{interval_type[0].lower()}"
+
+    df = values.copy()
+    # Coerce date-time to datetimes; drop rows without a valid timestamp because
+    # they cannot be resampled. Sort and deduplicate the index to ensure
+    # deterministic resampling behavior.
+    df["date-time"] = pd.to_datetime(df["date-time"], errors="coerce")
+    df = df.dropna(subset=["date-time"]).copy()
+    if df.empty:
+        return df
+    df = df.set_index("date-time")
+    df = df.sort_index()
+    # If duplicate timestamps exist, keep the first occurrence (matching prior
+    # behavior of using .first() during resample).
+    df = df[~df.index.duplicated(keep="first")]
+
+    current_delta = None
+    try:
+        inferred = pd.infer_freq(df.index)
+        if inferred:
+            current_delta = pd.to_timedelta(inferred)
+    except Exception:
+        current_delta = None
+
+    if current_delta is None:
+        diffs = df.index.to_series().diff().dropna()
+        if not diffs.empty:
+            current_delta = diffs.median()
+
+    try:
+        target_delta = pd.to_timedelta(target_str)
+    except Exception:
+        target_delta = None
+
+    if target_delta is not None and (
+        current_delta is None or current_delta != target_delta
+    ):
+        logging.info(
+            f"Resampling {ts_id}: from {current_delta} to {target_delta} (target={target_str})"
+        )
+        df_resampled = df.resample(target_str).first()
+        return df_resampled.reset_index()
+
+    return df.reset_index()

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/cwmscli/utils/deps.py

@@ -1,6 +1,7 @@
 import importlib
 import importlib.metadata
 import os
+from typing import Callable
 
 import click
 
@@ -57,6 +58,15 @@ def requires(*requirements):
             missing = []
             version_issues = []
 
+            # choose a version parsing function: prefer packaging, fallback to pkg_resources
+            try:
+                from packaging.version import parse as _parse_version
+            except Exception:
+                try:
+                    from pkg_resources import parse_version as _parse_version
+                except Exception:
+                    _parse_version = None
+
             for req in requirements:
                 mod = req["module"]
                 pkg = req.get("package", mod)
@@ -78,12 +88,32 @@ def requires(*requirements):
                 if min_version:
                     try:
                         actual_version = importlib.metadata.version(pkg)
-                        if actual_version < min_version:
-                            version_issues.append(
-                                f"- python package `{pkg}` version `{actual_version}` found, "
-                                f"but `{min_version}` or higher is required.\n\t"
-                                f"Update the packge to the required minimum version to use this command."
-                            )
+                        if _parse_version is not None:
+                            try:
+                                if _parse_version(actual_version) < _parse_version(
+                                    min_version
+                                ):
+                                    version_issues.append(
+                                        f"- python package `{pkg}` version `{actual_version}` found, "
+                                        f"but `{min_version}` or higher is required.\n\t"
+                                        f"Update the package to the required minimum version to use this command."
+                                    )
+                            except Exception:
+                                # Fall back to string comparison if parsing fails
+                                if actual_version < min_version:
+                                    version_issues.append(
+                                        f"- python package `{pkg}` version `{actual_version}` found, "
+                                        f"but `{min_version}` or higher is required.\n\t"
+                                        f"Update the package to the required minimum version to use this command."
+                                    )
+                        else:
+                            # No parser available — fall back to lexical comparison
+                            if actual_version < min_version:
+                                version_issues.append(
+                                    f"- python package `{pkg}` version `{actual_version}` found, "
+                                    f"but `{min_version}` or higher is required.\n\t"
+                                    f"Update the package to the required minimum version to use this command."
+                                )
                     except importlib.metadata.PackageNotFoundError:
                         version_issues.append(
                             f"- `{pkg}` is installed but version could not be verified"

{cwms_cli-0.8.1 → cwms_cli-0.9.0}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "cwms-cli"
 repository = "https://github.com/HydrologicEngineeringCenter/cwms-cli"
 
-version = "0.8.1"
+version = "0.9.0"
 
 
 packages = [