cwms-cli 0.1.5__tar.gz → 0.2.1__tar.gz

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwms-cli
-Version: 0.1.5
+Version: 0.2.1
 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.1.5 → cwms_cli-0.2.1}/cwmscli/__init__.py

@@ -1,5 +1,7 @@
 import logging as lg
 
+from cwmscli import load
+
 # create logging for logging
 logging = lg.getLogger()
 if logging.hasHandlers():

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/__main__.py

@@ -1,6 +1,7 @@
 import click
 
 from cwmscli.commands import commands_cwms
+from cwmscli.load import __main__ as load
 from cwmscli.usgs import usgs_group
 
 
@@ -13,3 +14,4 @@ cli.add_command(usgs_group, name="usgs")
 cli.add_command(commands_cwms.shefcritimport)
 cli.add_command(commands_cwms.csv2cwms_cmd)
 cli.add_command(commands_cwms.blob_group)
+cli.add_command(load.load_group)

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/commands/blob.py

@@ -7,10 +7,6 @@ import re
 import sys
 from typing import Optional, Sequence
 
-import cwms
-import pandas as pd
-import requests
-
 from cwmscli.utils import get_api_key
 from cwmscli.utils.deps import requires
 
@@ -90,6 +86,9 @@ def _save_base64(
 
 
 def store_blob(**kwargs):
+    import cwms
+    import requests
+
     file_data = kwargs.get("file_data")
     blob_id = kwargs.get("blob_id", "").upper()
     # Attempt to determine what media type should be used for the mime-type if one is not presented based on the file extension
@@ -145,6 +144,9 @@ def store_blob(**kwargs):
 
 
 def retrieve_blob(**kwargs):
+    import cwms
+    import requests
+
     blob_id = kwargs.get("blob_id", "").upper()
     if not blob_id:
         logging.warning(
@@ -172,14 +174,17 @@ def retrieve_blob(**kwargs):
 
 
 def delete_blob(**kwargs):
+    import cwms
+    import requests
+
     blob_id = kwargs.get("blob_id").upper()
     logging.debug(f"Office: {kwargs.get('office')}  Blob ID: {blob_id}")
 
     try:
-        # cwms.delete_blob(
-        #     office_id=kwargs.get("office"),
-        #     blob_id=kwargs.get("blob_id").upper(),
-        # )
+        cwms.delete_blob(
+            office_id=kwargs.get("office"),
+            blob_id=kwargs.get("blob_id").upper(),
+        )
         logging.info(f"Successfully deleted blob with ID: {blob_id}")
     except requests.HTTPError as e:
         details = getattr(e.response, "text", "") or str(e)
@@ -197,8 +202,11 @@ def list_blobs(
     sort_by: Optional[Sequence[str]] = None,
     ascending: bool = True,
     limit: Optional[int] = None,
-) -> pd.DataFrame:
+):
     logging.info(f"Listing blobs for office: {office!r}...")
+    import cwms
+    import pandas as pd
+
     result = cwms.get_blobs(office_id=office, blob_id_like=blob_id_like)
 
     # Accept either a DataFrame or a JSON/dict-like response
@@ -250,6 +258,9 @@ def upload_cmd(
     api_root: str,
     api_key: str,
 ):
+    import cwms
+    import requests
+
     cwms.init_session(api_root=api_root, api_key=get_api_key(api_key, ""))
     try:
         file_size = os.path.getsize(input_file)
@@ -307,6 +318,9 @@ def upload_cmd(
 def download_cmd(
     blob_id: str, dest: str, office: str, api_root: str, api_key: str, dry_run: bool
 ):
+    import cwms
+    import requests
+
     if dry_run:
         logging.info(
             f"DRY RUN: would GET {api_root} blob with blob-id={blob_id} office={office}."
@@ -331,6 +345,7 @@ def download_cmd(
 
 
 def delete_cmd(blob_id: str, office: str, api_root: str, api_key: str, dry_run: bool):
+    import cwms
 
     if dry_run:
         logging.info(
@@ -353,6 +368,8 @@ def update_cmd(
     api_root: str,
     api_key: str,
 ):
+    import cwms
+
     if dry_run:
         logging.info(
             f"DRY RUN: would PATCH {api_root} blob with blob-id={blob_id} office={office}"
@@ -399,6 +416,9 @@ def list_cmd(
     api_root: str,
     api_key: str,
 ):
+    import cwms
+    import pandas as pd
+
     cwms.init_session(api_root=api_root, api_key=get_api_key(api_key, None))
     df = list_blobs(
         office=office,

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/commands/commands_cwms.py

@@ -107,7 +107,6 @@ def csv2cwms_cmd(**kwargs):
 """
     ),
 )
-@requires(reqs.cwms)
 def blob_group():
     pass
 
@@ -130,13 +129,14 @@ def blob_group():
     help="Override media type (guessed from file if omitted).",
 )
 @click.option(
-    "--overwrite/--no-overwrite",
+    "--overwrite",
     default=False,
     show_default=True,
     help="If true, replace existing blob.",
 )
 @click.option("--dry-run", is_flag=True, help="Show request; do not send.")
 @common_api_options
+@requires(reqs.cwms)
 def blob_upload(**kwargs):
     from cwmscli.commands.blob import upload_cmd
 
@@ -156,6 +156,7 @@ def blob_upload(**kwargs):
 )
 @click.option("--dry-run", is_flag=True, help="Show request; do not send.")
 @common_api_options
+@requires(reqs.cwms)
 def blob_download(**kwargs):
     from cwmscli.commands.blob import download_cmd
 
@@ -169,6 +170,7 @@ def blob_download(**kwargs):
 @click.option("--blob-id", required=True, type=str, help="Blob ID to delete.")
 @click.option("--dry-run", is_flag=True, help="Show request; do not send.")
 @common_api_options
+@requires(reqs.cwms)
 def delete_cmd(**kwargs):
     from cwmscli.commands.blob import delete_cmd
 
@@ -204,6 +206,7 @@ def delete_cmd(**kwargs):
     help="If true, replace existing blob.",
 )
 @common_api_options
+@requires(reqs.cwms)
 def update_cmd(**kwargs):
     from cwmscli.commands.blob import update_cmd
 
@@ -243,6 +246,7 @@ def update_cmd(**kwargs):
     help="If set, write results to this CSV file.",
 )
 @common_api_options
+@requires(reqs.cwms)
 def list_cmd(**kwargs):
     from cwmscli.commands.blob import list_cmd
 

cwms_cli-0.2.1/cwmscli/load/README.md

@@ -0,0 +1,7 @@
+# Loader Scripts
+
+This command supports loading data in some form or fashion.
+
+Initially it was intended to load data across from one CDA instance (GET) to another (POST). But could be expanded to other forms of loading including backloading jobs that potentially wrap existing other commands.
+
+It differs from the other scripts in that it is effectively a `CDA2CDA` script which is usually only needed for `loading` data in initial setups. (Dev/Docker Compose)

cwms_cli-0.2.1/cwmscli/load/__main__.py

@@ -0,0 +1,5 @@
+# cwmscli/load/__main__.py
+# Side-effect imports to register subcommands under `load_group`
+from cwmscli.load.location import location as _locations
+from cwmscli.load.root import load_group  # export for callers
+from cwmscli.load.timeseries import timeseries as _timeseries

cwms_cli-0.2.1/cwmscli/load/location/location.py

@@ -0,0 +1,131 @@
+# cwmscli/load/locations.py
+from typing import Iterable, Optional
+
+import click
+
+from cwmscli import requirements as reqs
+from cwmscli.load.root import (
+    load_group,
+    shared_source_target_options,
+    validate_cda_targets,
+)
+from cwmscli.utils.deps import requires
+
+
+@load_group.group(
+    "location", help="Copy location data from a source CDA to a target CDA."
+)
+@click.pass_context
+def location(ctx):
+    pass
+
+
+@location.command(
+    "ids-all",
+    help="Copy ALL locations from a source CDA to a target CDA.",
+)
+@shared_source_target_options
+@click.option(
+    "--like",
+    default=None,
+    type=str,
+    help="LIKE filter for location name (e.g. 'Turbine*').",
+)
+@click.option(
+    "--location-kind-like",
+    "location_kind_like",
+    default=["ALL"],
+    multiple=True,
+    help=(
+        "Filter by LOCATION_KIND using LIKE; may be passed multiple times.\n\n"
+        "Default is to pull all Location kinds.\n\n"
+        "Common kinds: SITE, EMBANKMENT, OVERFLOW, TURBINE, STREAM, PROJECT, "
+        "STREAMGAGE, BASIN, OUTLET, LOCK, GATE.\n\n"
+        "Examples:\n"
+        "  --location-kind-like PROJECT --location-kind-like STREAM\n"
+        "  --location-kind-like '(SITE|STREAM)'   # Posix regex"
+    ),
+)
+@requires(reqs.cwms)
+@validate_cda_targets
+def load_locations(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    dry_run: bool,
+    like: Optional[str],
+    location_kind_like: Optional[Iterable[str]] = None,
+):
+    from cwmscli.load.location.location_ids import load_locations as _load_locations
+
+    _load_locations(
+        source_cda=source_cda,
+        source_office=source_office,
+        target_cda=target_cda,
+        target_api_key=target_api_key,
+        verbose=verbose,
+        dry_run=dry_run,
+        like=like,
+        location_kind_like=location_kind_like,
+    )
+
+
+@location.command(
+    "ids-bygroup",
+    help="Copy locations from a CWMS Location Group (source CDA) to a target CDA.",
+)
+@shared_source_target_options
+@click.option(
+    "--group-id", required=True, help="Location Group ID (e.g., 'Ark Basin')."
+)
+@click.option(
+    "--category-id", required=True, help="Location Category ID (e.g., 'Basin')."
+)
+@click.option(
+    "--group-office-id",
+    default=None,
+    help="Owning office of the Location Group (defaults to --source-office).",
+)
+@click.option(
+    "--category-office-id",
+    default=None,
+    help="Owning office of the Category (defaults to --source-office).",
+)
+@click.option(
+    "--filter-office/--no-filter-office",
+    default=True,
+    show_default=True,
+    help="If set, only copy members whose 'office-id' equals --source-office.",
+)
+@requires(reqs.cwms)
+@validate_cda_targets
+def load_locations_from_group(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    group_id: str,
+    category_id: str,
+    group_office_id: Optional[str],
+    category_office_id: Optional[str],
+    filter_office: bool,
+    dry_run: bool,
+):
+    from cwmscli.load.location.location_ids_bygroup import copy_from_group
+
+    copy_from_group(
+        source_cda=source_cda,
+        source_office=source_office,
+        target_cda=target_cda,
+        target_api_key=target_api_key,
+        verbose=verbose,
+        group_id=group_id,
+        category_id=category_id,
+        group_office_id=group_office_id,
+        category_office_id=category_office_id,
+        filter_office=filter_office,
+        dry_run=dry_run,
+    )

cwms_cli-0.2.1/cwmscli/load/location/location_ids.py

@@ -0,0 +1,83 @@
+from typing import Iterable, Optional
+
+import click
+import cwms
+
+
+def load_locations(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    dry_run: bool,
+    like: Optional[str],
+    location_kind_like: Optional[Iterable[str]] = "ALL",
+):
+    if verbose:
+        click.echo(
+            f"[load locations] source={source_cda} ({source_office}) -> target={target_cda}"
+        )
+        click.echo(
+            f"  like={like or '-'}  kinds={list(location_kind_like) or '-'}  dry_run={dry_run}"
+        )
+
+    cwms.init_session(api_root=source_cda, api_key=None)
+
+    cat_kwargs = {"office_id": source_office}
+    if like:
+        cat_kwargs["like"] = like
+    kinds = list(location_kind_like) if location_kind_like else [None]
+
+    locations = []
+
+    if "ALL" in kinds:
+        locations = cwms.get_locations(office_id=source_office).json
+    else:
+        locations = []
+        for kind in kinds:
+            cat_kwargs_k = dict(cat_kwargs)
+            if kind != "ALL":
+                cat_kwargs_k["location_kind_like"] = kind
+
+            if verbose >= 2:
+                click.echo(f"  > catalog query: {cat_kwargs_k}")
+
+            resp = cwms.get_locations_catalog(**cat_kwargs_k)
+            if resp.df.empty:
+                continue
+
+            loc_ids = resp.df["name"].tolist()
+            locations_resp = cwms.get_locations(
+                office_id=source_office, location_ids=loc_ids
+            )
+            locations.extend(locations_resp.json or [])
+
+    if verbose:
+        click.echo(f"Fetched {len(locations)} locations from source")
+
+    if dry_run:
+        for loc in locations:
+            click.echo(
+                f"[dry-run] would store Location(name={loc['name']}) to {target_cda} ({source_office})"
+            )
+        return
+
+    # init target once
+    cwms.init_session(api_root=target_cda, api_key=target_api_key)
+
+    errors = 0
+    for loc in locations:
+        try:
+            if loc["active"] is True:
+                result = cwms.store_location(data=loc, fail_if_exists=False)
+                if verbose:
+                    click.echo(result)
+        except Exception as e:
+            errors += 1
+            click.echo(f"Error storing location {loc}: \n\t{e}", err=True)
+
+    if errors:
+        raise click.ClickException(f"Completed with {errors} error(s).")
+    if verbose:
+        click.echo("Done.")

cwms_cli-0.2.1/cwmscli/load/location/location_ids_bygroup.py

@@ -0,0 +1,127 @@
+# cwmscli/load/location_group.py
+import re
+from typing import Optional
+
+import click
+import cwms
+
+
+def exact_or_regex(ids: list[str]) -> str:
+    if not ids:
+        return r"^$"
+    if len(ids) == 1:
+        return rf"^{re.escape(ids[0])}$"
+    return r"^(?:" + "|".join(re.escape(x) for x in ids) + r")$"
+
+
+def copy_from_group(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    group_id: str,
+    category_id: str,
+    group_office_id: Optional[str],
+    category_office_id: Optional[str],
+    filter_office: bool,
+    dry_run: bool,
+):
+    group_office_id = group_office_id or source_office
+    category_office_id = category_office_id or source_office
+
+    if verbose:
+        click.echo(
+            f"[load location group] source={source_cda} ({source_office}) -> target={target_cda})"
+        )
+        click.echo(
+            f"  group={group_id}  category={category_id}  "
+            f"group_office={group_office_id}  category_office={category_office_id} "
+            f"filter_office={filter_office}  dry_run={dry_run}"
+        )
+
+    cwms.init_session(api_root=source_cda, api_key=None)
+
+    try:
+        grp = cwms.get_location_group(
+            loc_group_id=group_id,
+            category_id=category_id,
+            office_id=source_office,
+            group_office_id=group_office_id,
+            category_office_id=category_office_id,
+        )
+        if verbose:
+            click.echo(f"Fetched Location Group '{group_id}' from source:")
+            if hasattr(grp, "df"):
+                click.echo(grp.df)
+            else:
+                click.echo(grp.json)
+    except Exception as e:
+        raise click.ClickException(
+            f"Failed to read location group '{group_id}' in category '{category_id}': {e}"
+        )
+
+    df = getattr(grp, "df", None)
+    if df is None or df.empty:
+        click.echo("No members found in the specified location group.")
+        return
+
+    if filter_office and "office-id" in df.columns:
+        df = df[df["office-id"] == source_office].copy()
+
+    member_ids = sorted(df["location-id"].dropna().unique().tolist())
+    if verbose:
+        click.echo(f"Group members found: {len(member_ids)}")
+    if not member_ids:
+        click.echo("No valid location IDs to copy.")
+        return
+
+    try:
+        locations = []
+        BATCH = 200  # optional batching
+        for batch in (
+            member_ids[i : i + BATCH] for i in range(0, len(member_ids), BATCH)
+        ):
+            pattern = exact_or_regex(batch)
+            resp = cwms.get_locations(office_id=source_office, location_ids=pattern)
+            if verbose and getattr(resp, "df", None) is not None:
+                click.echo(f"Fetched {len(resp.df)} matching Locations in batch")
+            if resp and resp.json:
+                locations.extend(resp.json)
+
+    except Exception as e:
+        raise click.ClickException(f"Failed to fetch locations from source: {e}")
+
+    if verbose:
+        click.echo(f"Fetched {len(locations)} Location objects from source")
+
+    if dry_run:
+        for loc in locations:
+            click.echo(
+                f"[dry-run] would store Location(name={loc.name}) to {target_cda} ({source_office})"
+            )
+        return
+
+    try:
+        cwms.init_session(api_root=target_cda, api_key=target_api_key)
+    except Exception as e:
+        raise click.ClickException(f"Failed to init target session: {e}")
+
+    errors = 0
+    for loc in locations:
+        try:
+            if verbose:
+                click.echo(f"Store: {loc['name']}")
+            cwms.store_location(data=loc, fail_if_exists=False)
+            if verbose:
+                click.echo("\tStored successfully.")
+        except Exception as e:
+            errors += 1
+            click.echo(f"Error storing location {loc}: \n\t{e}", err=True)
+
+    click.echo(
+        f"Successfully stored {len(locations) - errors} / {len(locations)} locations."
+    )
+
+    if errors:
+        raise click.ClickException(f"Completed with {errors} error(s).")

cwms_cli-0.2.1/cwmscli/load/root.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import functools
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import urlparse
+
+import click
+
+from cwmscli import requirements as reqs
+from cwmscli.utils.deps import requires
+
+CONTEXT = dict(
+    help_option_names=["-h", "--help"],
+    max_content_width=160,
+)
+
+
+@dataclass
+class CdaEndpoints:
+    source_cda: str
+    source_office: str
+    target_cda: str
+    target_office: str
+    target_api_key: Optional[str] = None
+
+
+def _normalize_url(u: str) -> str:
+    if not u:
+        return ""
+    p = urlparse(u)
+    path = (p.path or "").rstrip("/")
+    return f"{p.scheme.lower()}://{p.netloc.lower()}{path}"
+
+
+def _norm_office(o: Optional[str]) -> str:
+    return (o or "").strip().upper()
+
+
+def validate_cda_targets(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        source_cda = _normalize_url(kwargs.get("source_cda"))
+        target_cda = _normalize_url(kwargs.get("target_cda"))
+        source_office = _norm_office(kwargs.get("source_office"))
+        target_office = _norm_office(kwargs.get("target_office"))
+
+        same_root = source_cda == target_cda and bool(source_cda)
+        same_office = source_office == target_office and bool(source_office)
+
+        if same_root and same_office:
+            raise click.ClickException(
+                "Circular reference detected: source and target CDA endpoints "
+                "are identical (URL + office). This would read-from and write-to "
+                "the same system.\n\nChange the source or target CDA URL or office. "
+                "Type cwms-cli load --help for arg options."
+            )
+        elif same_root and not same_office:
+            click.secho(
+                "Warning: source and target use the same CDA root URL but different offices. "
+                "This is allowed, but double-check intent.",
+                fg="yellow",
+            )
+
+        click.secho(
+            f"Source: {source_cda} (office={source_office or '-'})\n"
+            f"Target: {target_cda} (office={source_office or '-'})",
+            fg="green" if not same_root else "yellow",
+        )
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def shared_source_target_options(f):
+    f = click.option(
+        "--source-cda",
+        envvar="CDA_SOURCE_URL",
+        required=True,
+        default="https://cwms-data.usace.army.mil/cwms-data/",
+        help="Source CWMS Data API root. Default: https://cwms-data.usace.army.mil/cwms-data/",
+    )(f)
+    f = click.option(
+        "--source-office",
+        envvar="CDA_SOURCE_OFFICE",
+        required=True,
+        help="Source office ID (e.g. SWT, SWL).",
+    )(f)
+    f = click.option(
+        "--target-cda",
+        envvar="CDA_TARGET_URL",
+        required=True,
+        default="http://localhost:8081/cwms-data/",
+        help="Target CWMS Data API root. Default: http://localhost:8081/cwms-data/",
+    )(f)
+    f = click.option(
+        "--target-api-key",
+        envvar="CDA_API_KEY",
+        help="Target API key (if required by the target CDA).",
+    )(f)
+    f = click.option(
+        "--dry-run/--no-dry-run",
+        is_flag=True,
+        default=False,
+        show_default=True,
+        help="Show what would be written without storing to target.",
+    )(f)
+    f = click.option(
+        "-v",
+        "--verbose",
+        count=True,
+        help="Increase verbosity (repeat for more detail).",
+    )(f)
+    return f
+
+
+@click.group(
+    name="load",
+    help="Load data from one CWMS Data API instance to another.",
+    context_settings=CONTEXT,
+)
+def load_group():
+    pass

cwms_cli-0.2.1/cwmscli/load/timeseries/timeseries.py

@@ -0,0 +1,55 @@
+from typing import Optional
+
+import click
+
+from cwmscli import requirements as reqs
+from cwmscli.load.root import (
+    load_group,
+    shared_source_target_options,
+    validate_cda_targets,
+)
+from cwmscli.utils.deps import requires
+
+
+@load_group.group(
+    "timeseries", help="Copy timeseries IDs from a source CDA to a target CDA."
+)
+@click.pass_context
+def timeseries(ctx):
+    pass
+
+
+@timeseries.command(
+    "ids-all",
+    help="Copy ALL timeseries IDs for locations in a target CDA from a source CDA.",
+)
+@shared_source_target_options
+@click.option(
+    "--timeseries-id-regex",
+    "timeseries_id_regex",
+    default=None,
+    type=str,
+    help="regex filter for timeseries ID (e.g. 'LocID.*').",
+)
+@requires(reqs.cwms)
+@validate_cda_targets
+def load_timeseries_ids_all(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    timeseries_id_regex: Optional[str],
+    dry_run: bool,
+):
+    from cwmscli.load.timeseries.timeseries_ids import load_timeseries_ids
+
+    load_timeseries_ids(
+        source_cda=source_cda,
+        source_office=source_office,
+        target_cda=target_cda,
+        target_api_key=target_api_key,
+        verbose=verbose,
+        timeseries_id_regex=timeseries_id_regex,
+        dry_run=dry_run,
+    )

cwms_cli-0.2.1/cwmscli/load/timeseries/timeseries_ids.py

@@ -0,0 +1,71 @@
+# cwmscli/load/timeseries_ids.py
+from turtle import pd
+from typing import Optional
+
+import click
+import pandas as pd
+
+
+def load_timeseries_ids(
+    source_cda: str,
+    source_office: str,
+    target_cda: str,
+    target_api_key: Optional[str],
+    verbose: int,
+    dry_run: bool,
+    timeseries_id_regex: Optional[str] = None,
+):
+    import cwms
+
+    if verbose:
+        click.echo(
+            f"Loading timeseries IDs from source CDA '{source_cda}' (office '{source_office}') "
+            f"to target CDA '{target_cda}'."
+        )
+
+    cwms.init_session(api_root=source_cda, api_key=None)
+    ts_ids = cwms.get_timeseries_identifiers(
+        office_id=source_office, timeseries_id_regex=timeseries_id_regex
+    ).df
+
+    cwms.init_session(api_root=target_cda, api_key=target_api_key)
+    # only grab time_ids for locations that are in the target database
+    locations = cwms.get_locations_catalog(office_id=source_office)
+    ts_ids[["location-id", "param", "type", "int", "dur", "ver"]] = ts_ids[
+        "time-series-id"
+    ].str.split(".", expand=True)
+    locs = locations.df.rename(columns={"name": "location-id", "office": "office-id"})
+    ts_lo_ids = pd.merge(ts_ids, locs, how="inner", on=["location-id", "office-id"])
+
+    if verbose:
+        click.echo(f"Found {len(ts_lo_ids)} timeseries IDs to copy.")
+
+    errors = 0
+    for i, row in ts_lo_ids.iterrows():
+        ts_id = row["time-series-id"]
+        if dry_run:
+            click.echo(
+                f"[dry-run] would store Timeseries ID(name={ts_id}) to {target_cda} ({source_office})"
+            )
+            continue
+        t_id_json = {
+            "office-id": row["office-id"],
+            "time-series-id": ts_id,
+            "timezone-name": row["timezone-name"],
+            "interval-offset-minutes": float(row["interval-offset-minutes"]),
+            "active": row["active_x"],
+        }
+        try:
+            result = cwms.store_timeseries_identifier(
+                data=t_id_json, fail_if_exists=False
+            )
+            if verbose:
+                click.echo(result)
+        except Exception as e:
+            errors += 1
+            click.echo(f"Error storing location {ts_id}: \n\t{e}", err=True)
+
+    if errors:
+        raise click.ClickException(f"Completed with {errors} error(s).")
+    if verbose:
+        click.echo("Timeseries ID copy operation completed.")

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/usgs/__init__.py

@@ -1,17 +1,5 @@
 import click
 
-from cwmscli import requirements as reqs
-from cwmscli.utils.deps import requires
-
-
-@click.group()
-def usgs_group():
-    """USGS utilities"""
-    pass
-
-
-import click
-
 from cwmscli import requirements as reqs
 from cwmscli.utils import (
     api_key_loc_option,
@@ -22,6 +10,13 @@ from cwmscli.utils import (
 )
 from cwmscli.utils.deps import requires
 
+
+@click.group()
+def usgs_group():
+    """USGS utilities"""
+    pass
+
+
 days_back_option = click.option(
     "-d",
     "--days-back",

cwms_cli-0.2.1/cwmscli/usgs/__main__.py

@@ -0,0 +1,7 @@
+from cwmscli import requirements as reqs
+from cwmscli.utils.deps import requires
+
+
+@requires(reqs.cwms)
+def blob_group():
+    pass

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/usgs/getUSGS_ratings_cda.py

@@ -17,7 +17,6 @@ def getusgs_rating_cda(
     days_back: float = 1,
     rating_subset: list = None,
 ):
-
     api_key = "apikey " + api_key
     cwms.api.init_session(api_root=api_root, api_key=api_key)
     logging.info(f"CDA connection: {api_root}")
@@ -180,7 +179,6 @@ def get_begin_with_date(data, str_starts):
 
 
 def get_usgs_effective_date(data, rating_type):
-
     date_string = None
     if rating_type == "EXSA":
         line = data[data[0].str.startswith("# //RATING SHIFTED=")].iloc[0, 0]

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/usgs/getusgs_cda.py

@@ -14,7 +14,6 @@ def getusgs_cda(
     api_key: str,
     backfill_tsids: list = None,
 ):
-
     api_key = "apikey " + api_key
     cwms.api.init_session(api_root=api_root, api_key=api_key)
     logging.info(f"CDA connection: {api_root}")
@@ -249,7 +248,6 @@ def CWMS_writeData(USGS_ts, USGS_data, USGS_data_method, days_back):
             USGS_data_row = USGS_data_method.loc[USGS_Id_param]
         if USGS_data_row is not None:
             try:
-
                 # grab the time series values obtained from USGS API.
                 values_df = pd.DataFrame(USGS_data_row["values"])
                 if values_df.shape[0] > 1:

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/usgs/getusgs_measurements_cda.py

@@ -478,7 +478,6 @@ def check_and_drop_duplicates(df_store, df_existing):
     """
 
     if not df_existing.empty:
-
         # cast number columns as int, sometimes USGS won't resolve to int...drop those rows
         df_invalid = df_store[pd.to_numeric(df_store["number"], errors="coerce").isna()]
         if not df_invalid.empty:
@@ -603,7 +602,6 @@ def realtime_mode(DAYS_BACK_COLLECTED, DAYS_BACK_MODIFIED, measurement_site_df):
         f"Fetching USGS discharge measurements from {startDT.isoformat()} (modified in last {DAYS_BACK_MODIFIED} days)..."
     )
     try:
-
         df_meas_usgs, meta = nwis.get_discharge_measurements(
             # sites=["05058000", "05059500"],
             period=f"P{DAYS_BACK_COLLECTED}D",
@@ -829,9 +827,11 @@ def backfill_mode(BACKFILL_LIST, measurement_site_df):
             logging.info(
                 "Overwrite flag is off. Filtering out any conflicting measurements"
             )
-            df_store, df_rejected_number, df_rejected_instant = (
-                check_and_drop_duplicates(df_meas_usgs, df_existing)
-            )
+            (
+                df_store,
+                df_rejected_number,
+                df_rejected_instant,
+            ) = check_and_drop_duplicates(df_meas_usgs, df_existing)
 
             if not df_rejected_number.empty:
                 logging.info(

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/usgs/rating_ini_file_import.py

@@ -10,7 +10,6 @@ rating_types = {
 
 
 def rating_ini_file_import(api_root, api_key, ini_filename):
-
     api_key = "apikey " + api_key
     cwms.api.init_session(api_root=api_root, api_key=api_key)
 

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/cwmscli/utils/deps.py

@@ -1,9 +1,19 @@
 import importlib
 import importlib.metadata
+import os
 
 import click
 
 
+def _pip_command():
+    # Check OS to determine pip vs pip3
+    if os.name == "nt":
+        return "pip"
+    # Avoid potential issues with multiple python (2/3) versions on Unix/Linux systems
+    else:
+        return "pip3"
+
+
 def requires(*requirements):
     """
     Decorator that ensures required Python modules are installed and meet optional minimum version constraints.
@@ -84,7 +94,9 @@ def requires(*requirements):
                     error_lines.append("Missing module(s):")
                     for msg, _ in missing:
                         error_lines.append(msg)
-                    install_cmd = "pip install " + " ".join(pkg for _, pkg in missing)
+                    install_cmd = f"{_pip_command()} install " + " ".join(
+                        pkg for _, pkg in missing
+                    )
                     error_lines.append(
                         f"\nInstall missing packages:\n    {install_cmd}"
                     )

{cwms_cli-0.1.5 → cwms_cli-0.2.1}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "cwms-cli"
 repository = "https://github.com/HydrologicEngineeringCenter/cwms-cli"
 
-version = "0.1.5"
+version = "0.2.1"
 
 
 packages = [
@@ -25,7 +25,7 @@ black = "^24.2.0"
 isort = "^5.13.2"
 mypy = "^1.9.0"
 pre-commit = "^3.6.2"
-#pytest = "^8.1.1"
+pytest = { version = "^9.0.2", python = ">=3.10" }
 #pytest-cov = "^4.1.0"
 #pandas-stubs = "^2.2.1.240316"
 yamlfix = "^1.16.0"
@@ -44,4 +44,4 @@ explicit_start = false
 preserve_quotes = true
 
 [tool.poetry.scripts]
-cwms-cli = "cwmscli.__main__:cli"
+cwms-cli = "cwmscli.__main__:cli"