cwms-cli 0.3.1__tar.gz → 0.3.3__tar.gz

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwms-cli
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -30,9 +30,20 @@ A collection of scripts to create, read, update, list, and delete data through C
 ## Install
 
 ```sh
-pip3 install git+https://github.com/HydrologicEngineeringCenter/cwms-cli.git@main
+pip install cwms-cli
+```
+Note: You may need to run `python -m pip install cwms-cli` if PIP is not in your path.
+
+
+### Update
+```sh
+pip install cwms-cli --upgrade
+```
+
+Or as of version `0.3.0+`
+```sh
+cwms-cli update
 ```
-Note: If you are on Windows OS, you may just need to use the command `pip`
 
 ## Command line implementation
 

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/README.md

@@ -7,9 +7,20 @@ A collection of scripts to create, read, update, list, and delete data through C
 ## Install
 
 ```sh
-pip3 install git+https://github.com/HydrologicEngineeringCenter/cwms-cli.git@main
+pip install cwms-cli
+```
+Note: You may need to run `python -m pip install cwms-cli` if PIP is not in your path.
+
+
+### Update
+```sh
+pip install cwms-cli --upgrade
+```
+
+Or as of version `0.3.0+`
+```sh
+cwms-cli update
 ```
-Note: If you are on Windows OS, you may just need to use the command `pip`
 
 ## Command line implementation
 

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/cwmscli/__main__.py

@@ -52,6 +52,7 @@ def cli(log_file: Optional[str], no_color: bool, log_level: str) -> None:
 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.update_cli_cmd)
 cli.add_command(commands_cwms.blob_group)
 cli.add_command(load.load_group)
 add_version_to_help_tree(cli)

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/cwmscli/commands/commands_cwms.py

@@ -1,3 +1,5 @@
+import subprocess
+import sys
 import textwrap
 
 import click
@@ -7,6 +9,7 @@ from cwmscli.callbacks import csv_to_list
 from cwmscli.commands import csv2cwms
 from cwmscli.utils import api_key_loc_option, common_api_options, to_uppercase
 from cwmscli.utils.deps import requires
+from cwmscli.utils.version import get_cwms_cli_version
 
 
 @click.command(
@@ -62,13 +65,6 @@ def shefcritimport(filename, office, api_root, api_key, api_key_loc):
     type=click.Path(exists=True),
     help="Path to JSON config file",
 )
-@click.option(
-    "-df",
-    "--data-file",
-    "data_file",
-    type=str,
-    help="Override CSV file (else use config)",
-)
 @click.option("--log", show_default=True, help="Path to the log file.")
 @click.option("--dry-run", is_flag=True, help="Log only (no HTTP calls)")
 @click.option("--begin", type=str, help="YYYY-MM-DDTHH:MM (local to --tz)")
@@ -90,6 +86,48 @@ def csv2cwms_cmd(**kwargs):
     csv2_main(**kwargs)
 
 
+@click.command("update", help="Update cwms-cli to the latest version using pip.")
+@click.option(
+    "--pre",
+    is_flag=True,
+    default=False,
+    help="Include pre-release versions during update.",
+)
+@click.option(
+    "-y",
+    "--yes",
+    is_flag=True,
+    default=False,
+    help="Skip confirmation prompt and run update immediately.",
+)
+def update_cli_cmd(pre: bool, yes: bool) -> None:
+    current_version = get_cwms_cli_version()
+    click.echo(f"Current cwms-cli version: {current_version}")
+
+    cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "cwms-cli"]
+    if pre:
+        cmd.append("--pre")
+
+    if not yes:
+        proceed = click.confirm("Proceed with updating cwms-cli via pip?", default=True)
+        if not proceed:
+            click.echo("Update canceled.")
+            return
+
+    click.echo(f"Running: {' '.join(cmd)}")
+    try:
+        result = subprocess.run(cmd, check=False)
+    except OSError as e:
+        raise click.ClickException(f"Unable to run pip update command: {e}") from e
+
+    if result.returncode != 0:
+        raise click.ClickException(
+            "cwms-cli update failed. Please review pip output above."
+        )
+
+    click.echo("Update complete. Run `cwms-cli --version` to verify.")
+
+
 # region Blob
 # ================================================================================
 #  BLOB

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/README.md

@@ -0,0 +1,21 @@
+# CSV2CWMS
+
+Writes CSV timeseries data to CDA using a configuration file.
+
+For end-user documentation, use the Read the Docs pages for `csv2cwms`. Those
+pages are the primary source for usage, setup, configuration, and examples.
+
+Recommended starting points:
+
+- Command: https://cwms-cli.readthedocs.io/en/latest/cli/csv2cwms.html
+- Setup: https://cwms-cli.readthedocs.io/en/latest/cli/setup.html
+- Complete config Example: https://cwms-cli.readthedocs.io/en/latest/cli/csv2cwms_complete_config.html
+
+Canonical example files used by those docs:
+
+- `examples/complete_config.json`
+- `tests/data/sample_config.json`
+- `tests/data/sample_brok.csv`
+
+For contributors maintaining the docs, see the repository contribution guide in
+`CONTRIBUTING.md` and the source docs under `docs/cli/`.

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/__main__.py

@@ -0,0 +1,130 @@
+# Script Entry File
+import os
+import sys
+import time
+from datetime import datetime
+
+import cwms
+
+# Add the current directory to the path
+# This is necessary for the script to be run as a standalone script
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+
+try:
+    from cwmscli.utils.colors import c
+
+    from . import __author__, __license__, __version__
+    from .config import config_check as _config_check
+    from .config import resolve_input_files
+    from .parser import parse_file as _parse_file
+    from .transform import load_timeseries as _load_timeseries
+    from .utils import logger, read_config, safe_zoneinfo, setup_logger
+    from .writer import write_timeseries
+except ImportError:
+    from parser import parse_file as _parse_file
+
+    from __init__ import __author__, __license__, __version__
+    from config import config_check as _config_check
+    from config import resolve_input_files
+    from transform import load_timeseries as _load_timeseries
+    from utils import logger, read_config, safe_zoneinfo, setup_logger
+    from writer import write_timeseries
+
+    from cwmscli.utils.colors import c
+
+
+def parse_file(file_path, begin_time, date_format, timezone="GMT", file_config=None):
+    return _parse_file(
+        file_path,
+        begin_time,
+        date_format,
+        timezone=timezone,
+        file_config=file_config,
+        logger=logger,
+    )
+
+
+def load_timeseries(file_data, file_key, config):
+    return _load_timeseries(file_data, file_key, config, logger)
+
+
+def config_check(config):
+    return _config_check(config, logger)
+
+
+def _resolve_begin_time(tz, begin):
+    if begin:
+        try:
+            return datetime.strptime(begin, "%Y-%m-%dT%H:%M").replace(tzinfo=tz)
+        except ValueError as err:
+            raise ValueError("--begin must be in format YYYY-MM-DDTHH:MM") from err
+    return datetime.now(tz)
+
+
+def main(*args, **kwargs):
+    """
+    Main function to execute the scada_ts script.
+    This function serves as the entry point for the script.
+    """
+    start_time = time.time()
+    tz = safe_zoneinfo(kwargs.get("tz"))
+    begin_time = _resolve_begin_time(tz, kwargs.get("begin"))
+
+    cwms.api.init_session(
+        api_root=kwargs.get("api_root"), api_key=kwargs.get("api_key")
+    )
+    setup_logger(kwargs.get("log"), verbose=kwargs.get("verbose"))
+    logger.info(f"Begin time: {begin_time}")
+    logger.info(f"Timezone: {c(str(tz), 'cyan')}")
+
+    if kwargs.get("coop"):
+        host = os.getenv("CDA_COOP_HOST")
+        if not host:
+            raise ValueError(
+                "Environment variable CDA_COOP_HOST must be set to use --coop flag."
+            )
+
+    config_path = kwargs.get("config_path")
+    config = read_config(config_path)
+    config_check(config)
+    input_files = resolve_input_files(config, kwargs.get("input_keys"))
+    logger.info(f"Started for {','.join(input_files)} input files.")
+
+    for file_name in input_files:
+        config_item = config.get("input_files", {}).get(file_name, {})
+        data_file = config_item.get("data_path", "")
+        if not data_file:
+            logger.warning(
+                f"No data file specified for input-keys '{file_name}' in {config_path}. {c(f'Skipping {file_name}', 'red')}. Please provide a valid CSV file path by ensuring the 'data_path' key is set in the config."
+            )
+            continue
+
+        csv_data = parse_file(
+            data_file,
+            begin_time,
+            config_item.get("date_format"),
+            kwargs.get("tz"),
+            config_item,
+        )
+        try:
+            ts_data = load_timeseries(csv_data, file_name, config)
+        except ValueError as err:
+            logger.error(f"Error loading timeseries for {file_name}: {err}")
+            continue
+
+        write_timeseries(
+            file_name=file_name,
+            ts_data=ts_data,
+            config_item=config_item,
+            office=kwargs.get("office"),
+            dry_run=kwargs.get("dry_run"),
+            config_path=config_path,
+            logger=logger,
+        )
+
+    logger.debug(f"\tExecution time: {round(time.time() - start_time, 3)} seconds.")
+    logger.debug(f"\tMemory usage: {round(os.sys.getsizeof(locals()) / 1024, 2)} KB")
+
+
+if __name__ == "__main__":
+    main()

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/config.py

@@ -0,0 +1,119 @@
+from cwmscli.utils.colors import c
+
+from .doclinks import COMPLETE_CONFIG_DOC_URL, with_doc_links
+
+VALID_USE_IF_MULTIPLE = {"first", "last", "average", "error"}
+TOP_LEVEL_CONFIG_KEYS = {
+    "interval",
+    "round_to_nearest",
+    "use_if_multiple",
+    "input_files",
+    "projects",
+}
+FILE_CONFIG_KEYS = {
+    "data_path",
+    "store_rule",
+    "date_col",
+    "date_format",
+    "round_to_nearest",
+    "use_if_multiple",
+    "timeseries",
+}
+TIMESERIES_CONFIG_KEYS = {"columns", "units", "precision"}
+
+
+def _raise_invalid_keys(level_name, owner_name, invalid_keys):
+    invalid = ", ".join(sorted(invalid_keys))
+    owner = f" for {owner_name}" if owner_name else ""
+    raise ValueError(
+        with_doc_links(
+            f"Invalid configuration key(s) {c(invalid, 'yellow')} found in {level_name}{owner}.",
+            COMPLETE_CONFIG_DOC_URL,
+        )
+    )
+
+
+def _validate_allowed_keys(config, logger):
+    invalid_top_level = set(config) - TOP_LEVEL_CONFIG_KEYS
+    if invalid_top_level:
+        _raise_invalid_keys("top-level config", None, invalid_top_level)
+
+    input_files = config.get("input_files", {})
+    for file_key, file_data in input_files.items():
+        invalid_file_keys = set(file_data) - FILE_CONFIG_KEYS
+        if invalid_file_keys:
+            _raise_invalid_keys("input file config", file_key, invalid_file_keys)
+
+        timeseries = file_data.get("timeseries", {})
+        for ts_name, ts_data in timeseries.items():
+            invalid_ts_keys = set(ts_data) - TIMESERIES_CONFIG_KEYS
+            if invalid_ts_keys:
+                _raise_invalid_keys("timeseries config", ts_name, invalid_ts_keys)
+
+
+def resolve_use_if_multiple(config, file_config):
+    # File-specific setting takes precedence over global setting, default to "error" if not set
+    strategy = file_config.get(
+        "use_if_multiple", config.get("use_if_multiple", "error")
+    )
+    normalized = str(strategy).strip().lower()
+    if normalized not in VALID_USE_IF_MULTIPLE:
+        valid = ", ".join(sorted(VALID_USE_IF_MULTIPLE))
+        raise ValueError(
+            with_doc_links(
+                f"Invalid use_if_multiple value {c(str(strategy), 'yellow')}. Expected one of {c(valid, 'cyan')}.",
+                COMPLETE_CONFIG_DOC_URL,
+            )
+        )
+    return normalized
+
+
+def config_check(config, logger):
+    """Checks a configuration file for required keys."""
+    resolve_use_if_multiple(config, {})
+    if not config.get("interval"):
+        logger.warning(
+            "Configuration file does not contain an 'interval' key (and value in seconds), this is recommended per CSV file to avoid ambiguity."
+        )
+    if config.get("projects"):
+        logger.warning(
+            "Configuration file contains a 'projects' key, this has been renamed to 'input_files' for clarity. Continuing for backwards compatibility."
+        )
+        config["input_files"] = config.pop("projects")
+    _validate_allowed_keys(config, logger)
+    if not config.get("input_files"):
+        raise ValueError(
+            with_doc_links(
+                "Configuration file must contain an 'input_files' key.",
+                COMPLETE_CONFIG_DOC_URL,
+            )
+        )
+    for file_key, file_data in config.get("input_files").items():
+        resolve_use_if_multiple(config, file_data)
+        # Only check the specified keys or if all keys are specified
+        if file_key != "all" and file_key != file_key.lower():
+            continue
+        if not file_data.get("timeseries"):
+            raise ValueError(
+                with_doc_links(
+                    f"Configuration file must contain a 'timeseries' key for file '{file_key}'.",
+                    COMPLETE_CONFIG_DOC_URL,
+                )
+            )
+        for ts_name, ts_data in file_data.get("timeseries").items():
+            if not ts_data.get("columns"):
+                raise ValueError(
+                    with_doc_links(
+                        f"Configuration file must contain a 'columns' key for timeseries '{ts_name}' in file '{file_key}'.",
+                        COMPLETE_CONFIG_DOC_URL,
+                    )
+                )
+
+
+def resolve_input_files(config, input_keys):
+    input_files = config.get("input_files", {})
+    if input_keys:
+        if input_keys == "all":
+            return config.get("input_files", {}).keys()
+        return input_keys.split(",")
+    return input_files

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/doclinks.py

@@ -0,0 +1,16 @@
+DOCS_BASE_URL = "https://cwms-cli.readthedocs.io/en/latest/cli"
+COMPLETE_CONFIG_DOC_URL = f"{DOCS_BASE_URL}/csv2cwms_complete_config.html"
+SETUP_DOC_URL = f"{DOCS_BASE_URL}/setup.html"
+API_ARGUMENTS_DOC_URL = f"{DOCS_BASE_URL}/api_arguments.html"
+INTERVALS_DOC_URL = f"{DOCS_BASE_URL}/csv2cwms_intervals.html"
+COMMAND_DOC_URL = f"{DOCS_BASE_URL}/csv2cwms.html"
+
+
+def with_doc_links(message, *urls):
+    unique_urls = []
+    for url in urls:
+        if url and url not in unique_urls:
+            unique_urls.append(url)
+    if not unique_urls:
+        return message
+    return f"{message}\nSee documentation: {', '.join(unique_urls)}"

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/cwmscli/commands/csv2cwms/examples/complete_config.json

@@ -1,12 +1,18 @@
 {
     "interval": 3600,
+    "round_to_nearest": true,
+    "use_if_multiple": "last",
     "input_files": {
         "BROK": {
             "data_path": "cwmscli/commands/csv2cwms/tests/data/sample_brok.csv",
+            "store_rule": "REPLACE_ALL",
+            "date_col": "Time",
             "date_format": [
                 "%m/%d/%Y %H:%M:%S",
                 "%m/%d/%Y %H:%M"
             ],
+            "round_to_nearest": true,
+            "use_if_multiple": "last",
             "timeseries": {
                 "BROK.Elev.Inst.15Minutes.0.Rev-SCADA-cda": {
                     "columns": "Headwater",
@@ -16,4 +22,4 @@
             }
         }
     }
-}
+}

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/parser.py

@@ -0,0 +1,74 @@
+from cwmscli.utils.colors import c
+
+from .doclinks import COMPLETE_CONFIG_DOC_URL, with_doc_links
+from .utils import load_csv, parse_date, safe_zoneinfo
+
+
+def resolve_date_column(header, file_config):
+    date_col = file_config.get("date_col")
+    if date_col is None:
+        return 0, header[0] if header else ""
+
+    normalized_header = {col.strip().lower(): i for i, col in enumerate(header)}
+    date_col_name = str(date_col).strip()
+    date_col_index = normalized_header.get(date_col_name.lower())
+    if date_col_index is None:
+        raise ValueError(
+            with_doc_links(
+                "Configured date_col "
+                f"{c(date_col_name, 'yellow')} was not found in the input file. "
+                "Available CSV columns: "
+                f"{c(', '.join(header), 'cyan')}",
+                COMPLETE_CONFIG_DOC_URL,
+            )
+        )
+    return date_col_index, header[date_col_index]
+
+
+def parse_file(
+    file_path, begin_time, date_format, timezone="GMT", file_config=None, logger=None
+):
+    file_config = file_config or {}
+    csv_data = load_csv(file_path)
+    header = csv_data[0]
+    data = csv_data[1:]
+    ts_data = {}
+    source_timezone = safe_zoneinfo(timezone)
+    date_col_index, date_col_label = resolve_date_column(header, file_config)
+    if logger:
+        logger.debug(f"Begin time: {begin_time}")
+    for row in data:
+        # Skip empty rows or rows without a timestamp
+        if not row:
+            continue
+        if date_col_index >= len(row):
+            raise ValueError(
+                with_doc_links(
+                    f"Configured date_col {c(date_col_label, 'yellow')} is missing from a CSV row in {c(file_path, 'red')}.",
+                    COMPLETE_CONFIG_DOC_URL,
+                )
+            )
+        try:
+            row_datetime = parse_date(
+                row[date_col_index], tz_str=timezone, date_format=date_format
+            )
+        except ValueError as err:
+            if date_col_index == 0:
+                raise ValueError(
+                    with_doc_links(
+                        "Unable to parse a timestamp from the first CSV column "
+                        f"{c(date_col_label, 'yellow')} with value {c(str(row[0]), 'red')} in {c(file_path, 'red')}. "
+                        "If the timestamp is in a different column, set "
+                        f"{c('date_col', 'cyan')} in the input file config to that column name.",
+                        COMPLETE_CONFIG_DOC_URL,
+                    )
+                ) from err
+            raise ValueError(
+                with_doc_links(
+                    f"Unable to parse a timestamp from configured date_col {c(date_col_label, 'yellow')} "
+                    f"with value {c(str(row[date_col_index]), 'red')} in {c(file_path, 'red')}.",
+                    COMPLETE_CONFIG_DOC_URL,
+                )
+            ) from err
+        ts_data.setdefault(int(row_datetime.timestamp()), []).append(row)
+    return {"header": header, "data": ts_data, "source_timezone": source_timezone}

{cwms_cli-0.3.1 → cwms_cli-0.3.3}/cwmscli/commands/csv2cwms/tests/data/sample_config.json

@@ -1,5 +1,6 @@
 {
     "interval": null,
+    "use_if_multiple": "last",
     "input_files": {
         "BROK": {
             "data_path": "cwmscli/commands/csv2cwms/tests/data/sample_brok.csv",
@@ -42,4 +43,4 @@
             }
         }
     }
-}
+}

cwms_cli-0.3.3/cwmscli/commands/csv2cwms/tests/test_dateutils.py

@@ -0,0 +1,147 @@
+from datetime import datetime, timedelta
+
+import pytest
+
+from cwmscli.utils.intervals import ALL_INTERVAL_PARAMETERS
+
+from ..utils.dateutils import (
+    determine_interval,
+    interval_parameter_to_seconds,
+    parse_date,
+    round_datetime_to_interval,
+    safe_zoneinfo,
+)
+
+
+def test_parse_date_valid_formats():
+    tz = safe_zoneinfo("UTC")
+    expected = datetime(2025, 3, 25, 14, 30, tzinfo=tz)
+    assert parse_date("03/25/2025 14:30:00") == expected
+    assert parse_date("03/25/2025 14:30") == expected
+    assert parse_date("03/25/2025 14") == datetime(2025, 3, 25, 14, tzinfo=tz)
+
+
+def test_parse_date_invalid_format():
+    with pytest.raises(ValueError):
+        parse_date("25-03-2025")
+
+
+def test_parse_date_uses_single_user_format():
+    tz = safe_zoneinfo("UTC")
+    expected = datetime(2025, 3, 25, 14, 30, tzinfo=tz)
+    assert (
+        parse_date("2025/03/25 14:30", date_format="%Y/%m/%d %H:%M", tz_str="UTC")
+        == expected
+    )
+
+
+def test_parse_date_uses_ordered_format_list():
+    tz = safe_zoneinfo("UTC")
+    expected = datetime(2025, 3, 25, 14, 30, tzinfo=tz)
+    assert (
+        parse_date(
+            "2025-03-25 14:30",
+            date_format=["%m/%d/%Y %H:%M", "%Y-%m-%d %H:%M"],
+            tz_str="UTC",
+        )
+        == expected
+    )
+
+
+def test_interval_parameter_to_seconds():
+    assert interval_parameter_to_seconds("15Minutes") == 900
+    assert interval_parameter_to_seconds("1Hour") == 3600
+    assert interval_parameter_to_seconds("1Day") == 86400
+
+
+def test_interval_parameter_list_includes_schema_values():
+    assert "1Week" in ALL_INTERVAL_PARAMETERS
+    assert "~15Minutes" in ALL_INTERVAL_PARAMETERS
+    assert "1Decade" in ALL_INTERVAL_PARAMETERS
+
+
+def test_interval_parameter_to_seconds_rejects_irregular_interval():
+    with pytest.raises(ValueError):
+        interval_parameter_to_seconds("~15Minutes")
+
+
+def test_round_datetime_to_interval_hour():
+    tz = safe_zoneinfo("UTC")
+    dt = datetime(2025, 3, 25, 14, 31, tzinfo=tz)
+    assert round_datetime_to_interval(dt, "1Hour") == datetime(
+        2025, 3, 25, 15, 0, tzinfo=tz
+    )
+
+
+def test_round_datetime_to_interval_minutes():
+    tz = safe_zoneinfo("UTC")
+    dt = datetime(2025, 3, 25, 14, 8, tzinfo=tz)
+    assert round_datetime_to_interval(dt, "15Minutes") == datetime(
+        2025, 3, 25, 14, 15, tzinfo=tz
+    )
+
+
+def test_round_datetime_to_interval_5_minutes():
+    tz = safe_zoneinfo("UTC")
+    dt = datetime(2025, 3, 25, 14, 3, 31, tzinfo=tz)
+    assert round_datetime_to_interval(dt, "5Minutes") == datetime(
+        2025, 3, 25, 14, 5, tzinfo=tz
+    )
+
+
+def test_round_datetime_to_interval_30_minutes():
+    tz = safe_zoneinfo("UTC")
+    dt = datetime(2025, 3, 25, 14, 16, tzinfo=tz)
+    assert round_datetime_to_interval(dt, "30Minutes") == datetime(
+        2025, 3, 25, 14, 30, tzinfo=tz
+    )
+
+
+def test_determine_interval_regular_spacing():
+    now = datetime(2025, 3, 25, 14, 30, tzinfo=safe_zoneinfo("UTC"))
+    interval = 900  # 15 minutes
+    csv_data = {
+        int((now + timedelta(seconds=i * interval)).timestamp()): [] for i in range(5)
+    }
+    assert determine_interval(csv_data) == 900
+
+
+def test_determine_interval_mixed_spacing():
+    now = datetime(2025, 3, 25, 14, 30, tzinfo=safe_zoneinfo("UTC"))
+    timestamps = [
+        now,
+        now + timedelta(minutes=15),
+        now + timedelta(minutes=30),
+        now + timedelta(minutes=60),  # outlier
+        now + timedelta(minutes=45),
+    ]
+    csv_data = {int(dt.timestamp()): [] for dt in timestamps}
+    assert determine_interval(csv_data) == 900
+
+
+def test_determine_interval_duplicate_timestamps():
+    now = datetime(2025, 3, 25, 14, 30, tzinfo=safe_zoneinfo("UTC"))
+    timestamps = [
+        now,
+        now + timedelta(minutes=15),
+        now + timedelta(minutes=15),  # duplicate
+        now + timedelta(minutes=30),
+    ]
+    csv_data = {int(dt.timestamp()): [] for dt in timestamps}
+    assert determine_interval(csv_data) == 900
+
+
+def test_determine_interval_missing_values():
+    now = datetime(2025, 3, 25, 14, 30, tzinfo=safe_zoneinfo("UTC"))
+    csv_data = {
+        int((now + timedelta(minutes=15 * i)).timestamp()): []
+        for i in [0, 1, 3, 4]  # skip index 2 (30-minute gap)
+    }
+    assert determine_interval(csv_data) == 900
+
+
+def test_determine_interval_insufficient_data():
+    now = datetime(2025, 3, 25, 14, 30, tzinfo=safe_zoneinfo("UTC"))
+    csv_data = {int(now.timestamp()): []}  # only one row
+    with pytest.raises(ValueError):
+        determine_interval(csv_data)