cwms-python 1.1.0__tar.gz → 1.1.2__tar.gz

{cwms_python-1.1.0 → cwms_python-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwms-python
-Version: 1.1.0
+Version: 1.1.2
 Summary: Corps water management systems (CWMS) REST API for Data Retrieval of USACE water data
 License: LICENSE
 License-File: LICENSE
@@ -69,6 +69,47 @@ cwms.init_session(
 If both `token` and `api_key` are provided, `cwms-python` will use the token
 and log a warning.
 
+### HTTP connection pools
+
+Sessions created with `cwms.init_session(api_root=..., pool_connections=100)`
+configure the same connection pool size and retry policy for HTTP and HTTPS.
+This includes unencrypted internal HTTP CDA roots used by Batch jobs. The default
+pool retains up to 100 connections per host for reuse; it does not cap concurrent
+requests. Set `pool_connections` when creating the session to size that pool for
+your workload. A `Connection pool is full, discarding connection` warning means
+an extra connection is being closed instead of retained, not that a response or
+its data was discarded. Check raised exceptions for actual request failures.
+
+### Errors and debugging
+
+Failed HTTP requests raise `cwms.api.ApiError`. Its message includes the HTTP
+status, method, URL, and CDA response body (including incident details when
+provided). The original response is available as `error.response`. Custom
+user-management errors retain these details too. Network exceptions propagate
+with their original type. Invalid JSON responses raise `ApiError` with the
+decoding exception as the cause; empty response bodies return an empty dictionary.
+
+Concurrent time-series reads and writes raise `cwms.api.BatchError` if any
+series or chunk fails. It subclasses `RuntimeError`, and `error.failures`
+contains `(series_or_chunk, original_exception)` pairs for every failure.
+Reads do not return incomplete results as success. Successful writes are not
+rolled back. Failures while looking up time-series extents also propagate.
+Chunk retries are limited to connection errors, timeouts, and HTTP
+429/500/502/503/504; validation and other permanent errors fail immediately
+at the chunk layer. The shared HTTP adapter retains its existing retry policy.
+
+Enable request outcome and chunk diagnostics with Python logging:
+
+```python
+import logging
+
+logging.basicConfig(level=logging.WARNING)
+logging.getLogger("cwms").setLevel(logging.DEBUG)
+```
+
+Request diagnostics include the method, endpoint, and response status, without
+request bodies or authentication headers.
+
 ## Getting Started
 
 ```python

{cwms_python-1.1.0 → cwms_python-1.1.2}/README.md

@@ -38,6 +38,47 @@ cwms.init_session(
 If both `token` and `api_key` are provided, `cwms-python` will use the token
 and log a warning.
 
+### HTTP connection pools
+
+Sessions created with `cwms.init_session(api_root=..., pool_connections=100)`
+configure the same connection pool size and retry policy for HTTP and HTTPS.
+This includes unencrypted internal HTTP CDA roots used by Batch jobs. The default
+pool retains up to 100 connections per host for reuse; it does not cap concurrent
+requests. Set `pool_connections` when creating the session to size that pool for
+your workload. A `Connection pool is full, discarding connection` warning means
+an extra connection is being closed instead of retained, not that a response or
+its data was discarded. Check raised exceptions for actual request failures.
+
+### Errors and debugging
+
+Failed HTTP requests raise `cwms.api.ApiError`. Its message includes the HTTP
+status, method, URL, and CDA response body (including incident details when
+provided). The original response is available as `error.response`. Custom
+user-management errors retain these details too. Network exceptions propagate
+with their original type. Invalid JSON responses raise `ApiError` with the
+decoding exception as the cause; empty response bodies return an empty dictionary.
+
+Concurrent time-series reads and writes raise `cwms.api.BatchError` if any
+series or chunk fails. It subclasses `RuntimeError`, and `error.failures`
+contains `(series_or_chunk, original_exception)` pairs for every failure.
+Reads do not return incomplete results as success. Successful writes are not
+rolled back. Failures while looking up time-series extents also propagate.
+Chunk retries are limited to connection errors, timeouts, and HTTP
+429/500/502/503/504; validation and other permanent errors fail immediately
+at the chunk layer. The shared HTTP adapter retains its existing retry policy.
+
+Enable request outcome and chunk diagnostics with Python logging:
+
+```python
+import logging
+
+logging.basicConfig(level=logging.WARNING)
+logging.getLogger("cwms").setLevel(logging.DEBUG)
+```
+
+Request diagnostics include the method, endpoint, and response status, without
+request bodies or authentication headers.
+
 ## Getting Started
 
 ```python

{cwms_python-1.1.0 → cwms_python-1.1.2}/cwms/api.py

@@ -33,13 +33,14 @@ import base64
 import json
 import logging
 from http import HTTPStatus
-from json import JSONDecodeError
-from typing import Any, Optional, cast
+from typing import Any, Optional, Union, cast
 
 from requests import Response, adapters
+from requests.exceptions import JSONDecodeError, RequestException
 from requests.exceptions import RetryError as RequestsRetryError
 from requests_toolbelt import sessions  # type: ignore
 from requests_toolbelt.sessions import BaseUrlSession  # type: ignore
+from urllib3.exceptions import HTTPError as Urllib3HTTPError
 from urllib3.util.retry import Retry
 
 from cwms.cwms_types import JSON, RequestParams
@@ -47,6 +48,7 @@ from cwms.cwms_types import JSON, RequestParams
 # Specify the default API root URL and version.
 API_ROOT = "https://cwms-data.usace.army.mil/cwms-data/"
 API_VERSION = 2
+logger = logging.getLogger(__name__)
 
 # Specify whether LRTS will use new ID format
 USE_NEW_LRTS_IDS = False
@@ -71,6 +73,7 @@ adapter = adapters.HTTPAdapter(
     pool_connections=100, pool_maxsize=100, max_retries=retry_strategy
 )
 SESSION.mount("https://", adapter)
+SESSION.mount("http://", adapter)
 
 
 class InvalidVersion(Exception):
@@ -90,17 +93,19 @@ class ApiError(Exception):
         self.message = message
 
     def __str__(self) -> str:
-        if self.message:
-            return self.message
-
         # Include the request URL in the error message.
-        message = f"CWMS API Error ({self.response.url})"
+        message = f"CWMS API Error ({self.response.url}) {self.response.status_code}"
+        request = getattr(self.response, "request", None)
+        if request is not None:
+            message += f" {request.method}"
 
         # If a reason is provided in the response, add it to the message.
         if reason := self.response.reason:
             message += f" {reason}"
 
         message += "."
+        if self.message:
+            message += f" {self.message}"
 
         # Add additional context to help the user resolve the issue.
         hint = self.hint()
@@ -111,10 +116,7 @@ class ApiError(Exception):
         content = getattr(self.response, "content", None)
         if content:
             if isinstance(content, bytes):
-                try:
-                    text = content.decode("utf-8", errors="replace")
-                except Exception:
-                    text = repr(content)
+                text = content.decode("utf-8", errors="replace")
             else:
                 text = str(content)
             message += f" {text}"
@@ -130,6 +132,9 @@ class ApiError(Exception):
         if status == 400:
             return "Check that your parameters are correct."
         if status == 404:
+            request = getattr(self.response, "request", None)
+            if request is not None and request.method != "GET":
+                return "Check the CDA response body for the failed operation."
             return "May be the result of an empty query."
 
         # No hint for other codes
@@ -144,8 +149,29 @@ class PermissionError(ApiError):
     """Raised when the CDA request is not authorized for the current caller."""
 
 
-def _unwrap_retry_error(error: RequestsRetryError) -> Exception:
-    """Return the original retry cause when requests wraps it in RetryError."""
+class BatchError(RuntimeError):
+    """A concurrent operation failed; ``failures`` retains every original exception.
+
+    Each failure is a (series or chunk description, exception) pair. Successful
+    writes are not rolled back. This remains compatible with RuntimeError handlers.
+    """
+
+    def __init__(self, message: str, failures: list[tuple[str, Exception]]):
+        self.failures = failures
+        super().__init__(
+            message
+            + "\n"
+            + "\n".join(f"{context}: {error}" for context, error in failures)
+        )
+
+
+def _unwrap_retry_error(
+    error: RequestsRetryError,
+) -> Union[RequestException, Urllib3HTTPError]:
+    """Unwrap transport errors; retain RetryError for other causes.
+
+    Unknown causes remain available through the original wrapper's chain or args.
+    """
 
     current: Exception = error
     cause = error.__cause__
@@ -162,7 +188,9 @@ def _unwrap_retry_error(error: RequestsRetryError) -> Exception:
                 current = reason
                 reason = getattr(current, "reason", None)
 
-    return current
+    if isinstance(current, (RequestException, Urllib3HTTPError)):
+        return current
+    return error
 
 
 def init_session(
@@ -185,6 +213,9 @@ def init_session(
         api_key (optional): An authentication key.
         token (optional): A Keycloak access token. If both token and api_key are
             provided, token is used.
+        pool_connections (optional): Number of host pools and reusable connections
+            per host when creating a session with api_root. Defaults to 100 for
+            both HTTP and HTTPS; this is not a limit on concurrent requests.
 
     Returns:
         Returns the updated session object.
@@ -202,6 +233,7 @@ def init_session(
             max_retries=retry_strategy,
         )
         SESSION.mount("https://", adapter)
+        SESSION.mount("http://", adapter)
     if token:
         if api_key:
             logging.warning(
@@ -336,6 +368,8 @@ def get_xml(
 
 
 def _process_response(response: Response) -> Any:
+    if not response.content:
+        return {}
     try:
         # Avoid case sensitivity issues with the content type header
         content_type = response.headers.get("Content-Type", "").lower()
@@ -356,10 +390,14 @@ def _process_response(response: Response) -> Any:
         # Fallback for remaining content types
         return response.content.decode("utf-8")
     except JSONDecodeError as error:
-        logging.error(
-            f"Error decoding CDA response as JSON: {error} on line {error.lineno}\n\tFalling back to text"
-        )
-        return response.text
+        raise ApiError(response, "Invalid JSON in CDA response.") from error
+
+
+def _check_response(response: Response, method: str, endpoint: str) -> None:
+    """Record request outcomes without logging credentials or request bodies."""
+    logger.debug("CDA %s %s returned HTTP %s", method, endpoint, response.status_code)
+    if not response.ok:
+        raise ApiError(response)
 
 
 def get(
@@ -391,12 +429,16 @@ def get(
     }
     try:
         with SESSION.get(endpoint, params=params, headers=headers) as response:
-            if not response.ok:
-                logging.error(f"CDA Error: response={response}")
-                raise ApiError(response)
+            _check_response(response, "GET", endpoint)
             return _process_response(response)
     except RequestsRetryError as error:
-        raise _unwrap_retry_error(error) from None
+        cause = _unwrap_retry_error(error)
+        if cause is error:
+            raise
+        raise cause from error
+    except RequestException as error:
+        logger.debug("CDA GET %s failed: %s", endpoint, type(error).__name__)
+        raise
 
 
 def get_with_paging(
@@ -459,12 +501,16 @@ def _post_function(
         with SESSION.post(
             endpoint, params=params, headers=headers, data=data
         ) as response:
-            if not response.ok:
-                logging.error(f"CDA Error: response={response}")
-                raise ApiError(response)
+            _check_response(response, "POST", endpoint)
             return response
     except RequestsRetryError as error:
-        raise _unwrap_retry_error(error) from None
+        cause = _unwrap_retry_error(error)
+        if cause is error:
+            raise
+        raise cause from error
+    except RequestException as error:
+        logger.debug("CDA POST %s failed: %s", endpoint, type(error).__name__)
+        raise
 
 
 def post(
@@ -556,17 +602,21 @@ def patch(
         "X-CWMS-LRTS-Formatting": str(USE_NEW_LRTS_IDS).lower(),
     }
 
-    if data and isinstance(data, dict) or isinstance(data, list):
+    if isinstance(data, (dict, list)):
         data = json.dumps(data)
     try:
         with SESSION.patch(
             endpoint, params=params, headers=headers, data=data
         ) as response:
-            if not response.ok:
-                logging.error(f"CDA Error: response={response}")
-                raise ApiError(response)
+            _check_response(response, "PATCH", endpoint)
     except RequestsRetryError as error:
-        raise _unwrap_retry_error(error) from None
+        cause = _unwrap_retry_error(error)
+        if cause is error:
+            raise
+        raise cause from error
+    except RequestException as error:
+        logger.debug("CDA PATCH %s failed: %s", endpoint, type(error).__name__)
+        raise
 
 
 def delete(
@@ -574,6 +624,7 @@ def delete(
     params: Optional[RequestParams] = None,
     *,
     api_version: int = API_VERSION,
+    data: Optional[Any] = None,
 ) -> None:
     """Make a DELETE request to the CWMS Data API.
 
@@ -584,6 +635,7 @@ def delete(
     Keyword Args:
         api_version (optional): The CDA version to use for the request. If not specified,
             the default API_VERSION will be used.
+        data (optional): Request body, JSON-encoded for dictionaries and lists.
 
     Raises:
         ApiError: If an error response is return by the API.
@@ -593,10 +645,20 @@ def delete(
         "Accept": api_version_text(api_version),
         "X-CWMS-LRTS-Formatting": str(USE_NEW_LRTS_IDS).lower(),
     }
+    kwargs: dict[str, Any] = {}
+    if data is not None:
+        headers["Content-Type"] = api_version_text(api_version)
+        kwargs["data"] = json.dumps(data) if isinstance(data, (dict, list)) else data
     try:
-        with SESSION.delete(endpoint, params=params, headers=headers) as response:
-            if not response.ok:
-                logging.error(f"CDA Error: response={response}")
-                raise ApiError(response)
+        with SESSION.delete(
+            endpoint, params=params, headers=headers, **kwargs
+        ) as response:
+            _check_response(response, "DELETE", endpoint)
     except RequestsRetryError as error:
-        raise _unwrap_retry_error(error) from None
+        cause = _unwrap_retry_error(error)
+        if cause is error:
+            raise
+        raise cause from error
+    except RequestException as error:
+        logger.debug("CDA DELETE %s failed: %s", endpoint, type(error).__name__)
+        raise

{cwms_python-1.1.0 → cwms_python-1.1.2}/cwms/ratings/ratings.py

@@ -424,8 +424,8 @@ def _validate_rating_params(
         raise ValueError(f"Invalid rating identifer: {rating_id}")
     try:
         ind_params, _ = parts[1].split(";")
-    except Exception:
-        raise ValueError(f"Invalid rating template: {parts[1]}")
+    except ValueError as error:
+        raise ValueError(f"Invalid rating template: {parts[1]}") from error
     if not office_id:
         raise ValueError("Cannot rate values without an office identifier")
     if not units:
@@ -466,8 +466,8 @@ def _perform_value_rating(
     ind_params = _validate_rating_params(rating_id, office_id, units, values)
     try:
         ind_units_str, dep_unit = units.split(";")
-    except Exception:
-        raise ValueError("Invalid units string")
+    except ValueError as error:
+        raise ValueError("Invalid units string") from error
     value_count = len(values[0])
     times = _get_times(value_count, times)
     if not rating_time:

{cwms_python-1.1.0 → cwms_python-1.1.2}/cwms/ratings/ratings_spec.py

@@ -127,7 +127,7 @@ def rating_spec_df_to_xml(data: pd.DataFrame) -> str:
     try:
         spec_xml += f"""
       <source-agency>{data.loc[0,'source-agency']}</source-agency>"""
-    except Exception:
+    except KeyError:
         spec_xml += """
       <source-agency/>"""
     spec_xml += f"""
@@ -154,7 +154,7 @@ def rating_spec_df_to_xml(data: pd.DataFrame) -> str:
     try:
         spec_xml2 += f"""
       <description>{data.loc[0,'description']}</description>"""
-    except Exception:
+    except KeyError:
         spec_xml2 += """
       <description/>"""
     spec_xml2 += """

{cwms_python-1.1.0 → cwms_python-1.1.2}/cwms/timeseries/timeseries.py

@@ -1,15 +1,87 @@
 import concurrent.futures
 import logging
+import re
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
 import pandas as pd
 from pandas import DataFrame
+from requests.exceptions import ConnectionError, Timeout
 
 import cwms.api as api
 from cwms.catalog.catalog import get_ts_extents
 from cwms.cwms_types import JSON, Data
 
+logger = logging.getLogger(__name__)
+
+_DEFAULT_CHUNK_DAYS = 365
+_MIN_INTERVAL_MINUTES = 2
+_FINE_INTERVAL_MINUTES = 15
+_FINE_INTERVAL_CHUNK_DAYS = 365
+_HOURLY_CHUNK_DAYS = 365
+_SIX_HOURLY_CHUNK_DAYS = 1460
+_COARSE_INTERVAL_CHUNK_DAYS = 2920
+_INTERVAL_PATTERN = re.compile(
+    r"^(?P<count>\d+)(?P<unit>"
+    r"Minute|Minutes|Hour|Hours|Day|Days|"
+    r"Week|Weeks|Month|Months|Year|Years)$"
+)
+_INTERVAL_MINUTES = {
+    "Minute": 1,
+    "Minutes": 1,
+    "Hour": 60,
+    "Hours": 60,
+    "Day": 24 * 60,
+    "Days": 24 * 60,
+    "Week": 7 * 24 * 60,
+    "Weeks": 7 * 24 * 60,
+    "Month": 30 * 24 * 60,
+    "Months": 30 * 24 * 60,
+    "Year": 365 * 24 * 60,
+    "Years": 365 * 24 * 60,
+}
+
+
+def get_timeseries_chunk_size(ts_id: str) -> timedelta:
+    """Return the default request chunk size for a time series interval.
+
+    Local regular time series intervals, such as ``~15Minutes``, use the same
+    chunk size as their regular interval. Unrecognized intervals retain the
+    conservative default used for 15-minute through hourly data.
+    """
+    ts_id_parts = ts_id.split(".")
+    if len(ts_id_parts) < 4:
+        return timedelta(days=_DEFAULT_CHUNK_DAYS)
+
+    interval = ts_id_parts[3].removeprefix("~")
+    match = _INTERVAL_PATTERN.fullmatch(interval)
+    if match is None:
+        return timedelta(days=_DEFAULT_CHUNK_DAYS)
+
+    interval_minutes = (
+        int(match.group("count")) * _INTERVAL_MINUTES[match.group("unit")]
+    )
+    if interval_minutes < _MIN_INTERVAL_MINUTES:
+        return timedelta(days=_DEFAULT_CHUNK_DAYS)
+
+    # These bands balance request overhead and response size based on production
+    # CDA timings. Fine intervals scale toward about 35,000 expected values.
+    if interval_minutes < _FINE_INTERVAL_MINUTES:
+        chunk_days = max(
+            1,
+            round(
+                _FINE_INTERVAL_CHUNK_DAYS * interval_minutes / _FINE_INTERVAL_MINUTES
+            ),
+        )
+    elif interval_minutes <= 60:
+        chunk_days = _HOURLY_CHUNK_DAYS
+    elif interval_minutes <= 6 * 60:
+        chunk_days = _SIX_HOURLY_CHUNK_DAYS
+    else:
+        chunk_days = _COARSE_INTERVAL_CHUNK_DAYS
+
+    return timedelta(days=chunk_days)
+
 
 def get_multi_timeseries_df(
     ts_ids: list[str],
@@ -60,45 +132,53 @@ def get_multi_timeseries_df(
     """
 
     def get_ts_ids(ts_id: str) -> Any:
-        try:
-            if ":" in ts_id:
-                ts_id, version_date = ts_id.split(":", 1)
-                version_date_dt = pd.to_datetime(version_date)
-            else:
-                version_date_dt = None
-            data = get_timeseries(
-                ts_id=ts_id,
-                office_id=office_id,
-                unit=unit,
-                begin=begin,
-                end=end,
-                version_date=version_date_dt,
-                multithread=False,
-            )
-            result_dict = {
-                "ts_id": ts_id,
-                "unit": data.json["units"],
-                "version_date": version_date_dt,
-                "values": data.df,
-            }
-            return result_dict
-        except Exception as e:
-            logging.error(f"Error processing {ts_id}: {e}")
-            return None
+        if ":" in ts_id:
+            ts_id, version_date = ts_id.split(":", 1)
+            version_date_dt = pd.to_datetime(version_date)
+        else:
+            version_date_dt = None
+        data = get_timeseries(
+            ts_id=ts_id,
+            office_id=office_id,
+            unit=unit,
+            begin=begin,
+            end=end,
+            version_date=version_date_dt,
+            multithread=False,
+        )
+        result_dict = {
+            "ts_id": ts_id,
+            "unit": data.json["units"],
+            "version_date": version_date_dt,
+            "values": data.df,
+        }
+        return result_dict
 
+    logger.debug(
+        "Fetching %s time series with up to %s workers", len(ts_ids), max_workers
+    )
+    failures: list[tuple[str, Exception]] = []
+    result_dict = []
     with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-        results = executor.map(get_ts_ids, ts_ids)
+        futures = [(ts_id, executor.submit(get_ts_ids, ts_id)) for ts_id in ts_ids]
+        for ts_id, future in futures:
+            try:
+                result_dict.append(future.result())
+            except Exception as error:
+                failures.append((ts_id, error))
+    if failures:
+        raise api.BatchError(
+            f"{len(failures)} time series failed to fetch:", failures
+        ) from failures[0][1]
 
-    result_dict = list(results)
     data = pd.DataFrame()
     for row in result_dict:
-        if row:
-            temp_df = row["values"]
-            temp_df = temp_df.assign(ts_id=row["ts_id"], units=row["unit"])
-            if "version_date" in row.keys():
-                temp_df = temp_df.assign(version_date=row["version_date"])
-            temp_df.dropna(how="all", axis=1, inplace=True)
-            data = pd.concat([data, temp_df], ignore_index=True)
+        temp_df = row["values"]
+        temp_df = temp_df.assign(ts_id=row["ts_id"], units=row["unit"])
+        if "version_date" in row.keys():
+            temp_df = temp_df.assign(version_date=row["version_date"])
+        temp_df.dropna(how="all", axis=1, inplace=True)
+        data = pd.concat([data, temp_df], ignore_index=True)
 
     if not melted and "date-time" in data.columns:
         cols = ["ts_id", "units"]
@@ -136,6 +216,9 @@ def chunk_timeseries_time_range(
     List[Tuple[datetime, datetime]]
         A list of tuples, where each tuple represents the start and end of a chunk.
     """
+    if chunk_size <= timedelta(0):
+        raise ValueError("chunk_size must be greater than zero")
+
     chunks = []
     current = begin
     while current < end:
@@ -162,16 +245,24 @@ _CHUNK_ATTEMPTS = 6
 
 
 def _call_with_retry(fn: Any, *args: Any, attempts: int = _CHUNK_ATTEMPTS) -> Any:
+    if attempts < 1:
+        raise ValueError("attempts must be at least 1")
     for i in range(attempts):
         try:
             return fn(*args)
-        except Exception as e:
+        except (api.ApiError, ConnectionError, Timeout) as e:
             status_code = getattr(getattr(e, "response", None), "status_code", None)
-            if status_code == 404:
+            if isinstance(e, api.ApiError) and status_code not in {
+                429,
+                500,
+                502,
+                503,
+                504,
+            }:
                 raise
             if i == attempts - 1:
                 raise
-            logging.warning(f"chunk attempt {i + 1}/{attempts} failed: {e}")
+            logger.warning(f"chunk attempt {i + 1}/{attempts} failed: {e}")
 
 
 def fetch_timeseries_chunks(
@@ -182,7 +273,7 @@ def fetch_timeseries_chunks(
     max_workers: int,
 ) -> List[Data]:
     results: List[Data] = []
-    errors: List[str] = []
+    errors: list[tuple[str, Exception]] = []
 
     with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
         future_to_chunk = {
@@ -206,14 +297,15 @@ def fetch_timeseries_chunks(
                 error_msg = (
                     f"Failed to fetch data from {chunk_start} to {chunk_end}: {e}"
                 )
-                logging.error(error_msg)
-                errors.append(error_msg)
+                logger.debug(error_msg)
+                errors.append(
+                    (f"Failed to fetch data from {chunk_start} to {chunk_end}", e)
+                )
 
     if errors:
-        raise RuntimeError(
-            f"{len(errors)} of {len(chunks)} chunk(s) failed to fetch:\n"
-            + "\n".join(errors)
-        )
+        raise api.BatchError(
+            f"{len(errors)} of {len(chunks)} chunk(s) failed to fetch:", errors
+        ) from errors[0][1]
 
     return results
 
@@ -298,7 +390,7 @@ def get_timeseries(
     trim: Optional[bool] = True,
     multithread: Optional[bool] = True,
     max_workers: int = 20,
-    max_days_per_chunk: int = 14,
+    max_days_per_chunk: Optional[int] = None,
 ) -> Data:
     """Retrieves time series values from a specified time series and time window.  Value date-times
     obtained are always in UTC.
@@ -338,15 +430,18 @@ def get_timeseries(
         trim: boolean, optional, default is True
             Specifies whether to trim missing values from the beginning and end of the retrieved values.
         multithread: boolean, optional, default is True
-            Specifies whether to trim missing values from the beginning and end of the retrieved values.
+            Specifies whether to retrieve time series chunks concurrently.
         max_workers: integer, default is 20
-            The maximum number of worker threads that will be spawned for multithreading, If calling more than 3 years of 15 minute data, consider using 30 max_workers
-        max_days_per_chunk: integer, default is 14
-            The maximum number of days that would be included in a thread. If calling more than 1 year of 15 minute data, consider using 30 days
+            The maximum number of worker threads used for concurrent requests.
+        max_days_per_chunk: integer, optional, default is None
+            The maximum number of days included in each request. By default,
+            the chunk size is selected from the time series interval.
     Returns
     -------
         cwms data type.  data.json will return the JSON output and data.df will return a dataframe. dates are all in UTC
     """
+    if max_days_per_chunk is not None and max_days_per_chunk <= 0:
+        raise ValueError("max_days_per_chunk must be greater than zero")
 
     selector = "values"
     endpoint = "timeseries"
@@ -367,27 +462,20 @@ def get_timeseries(
 
     # grab extents if begin is before CWMS DB were implemented to prevent empty queries outside of extents
     if begin < datetime(2014, 1, 1, tzinfo=timezone.utc) and multithread:
-        try:
-            begin_extent, _, _ = get_ts_extents(ts_id=ts_id, office_id=office_id)
-            # replace begin with begin extent if outside extents
-            if begin < begin_extent:
-                begin = begin_extent
-                logging.debug(
-                    f"Requested begin was before any data in this timeseries. Reseting to {begin}"
-                )
-        except Exception as e:
-            # If getting extents fails, fall back to single-threaded mode
-            logging.debug(
-                f"Could not retrieve time series extents ({e}). Falling back to single-threaded mode."
-            )
-
-            response = api.get_with_paging(
-                selector=selector, endpoint=endpoint, params=params
+        begin_extent, _, _ = get_ts_extents(ts_id=ts_id, office_id=office_id)
+        # replace begin with begin extent if outside extents
+        if begin < begin_extent:
+            begin = begin_extent
+            logger.debug(
+                f"Requested begin was before any data in this timeseries. Reseting to {begin}"
             )
-            return Data(response, selector=selector)
 
-    # divide the time range into chunks
-    chunks = chunk_timeseries_time_range(begin, end, timedelta(days=max_days_per_chunk))
+    chunk_size = (
+        timedelta(days=max_days_per_chunk)
+        if max_days_per_chunk is not None
+        else get_timeseries_chunk_size(ts_id)
+    )
+    chunks = chunk_timeseries_time_range(begin, end, chunk_size)
 
     # find max worker thread
     max_workers = max(min(len(chunks), max_workers), 1)
@@ -399,7 +487,7 @@ def get_timeseries(
         )
         return Data(response, selector=selector)
     else:
-        logging.debug(
+        logger.debug(
             f"Fetching {len(chunks)} chunks of timeseries data with {max_workers} threads"
         )
         # fetch the data
@@ -580,7 +668,7 @@ def store_multi_timeseries_df(
         ts_data_all["ts_id"].astype(str) + ":" + ts_data_all["version_date"].astype(str)
     ).unique()
 
-    errors: List[str] = []
+    errors: list[tuple[str, Exception]] = []
     with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
         futures = {}
         for unique_tsid in unique_tsids:
@@ -606,12 +694,12 @@ def store_multi_timeseries_df(
             try:
                 future.result()
             except Exception as e:
-                errors.append(f"{futures[future]}: {e}")
+                errors.append((str(futures[future]), e))
 
     if errors:
-        raise RuntimeError(
-            f"{len(errors)} time series failed to store:\n" + "\n".join(errors)
-        )
+        raise api.BatchError(
+            f"{len(errors)} time series failed to store:", errors
+        ) from errors[0][1]
 
 
 def chunk_timeseries_data(
@@ -711,13 +799,13 @@ def store_timeseries(
     _call_with_retry(api.post, endpoint, chunks[0], params)
     remaining_chunks = chunks[1:]
     actual_workers = min(max_workers, len(remaining_chunks))
-    logging.debug(
+    logger.debug(
         f"Storing {len(chunks)} chunks of timeseries data with {actual_workers} threads"
     )
 
     # Store chunks concurrently
     responses: List[Dict[str, Any]] = []
-    errors: List[str] = []
+    errors: list[tuple[str, Exception]] = []
 
     with concurrent.futures.ThreadPoolExecutor(max_workers=actual_workers) as executor:
         future_to_chunk = {
@@ -733,15 +821,16 @@ def store_timeseries(
                 start_time = chunk["values"][0][0]
                 end_time = chunk["values"][-1][0]
                 error_msg = f"Error storing chunk from {start_time} to {end_time}: {e}"
-                logging.error(error_msg)
-                errors.append(error_msg)
+                logger.debug(error_msg)
+                errors.append(
+                    (f"Error storing chunk from {start_time} to {end_time}", e)
+                )
                 responses.append({"error": error_msg})
 
     if errors:
-        raise RuntimeError(
-            f"{len(errors)} of {len(chunks)} chunk(s) failed to store:\n"
-            + "\n".join(errors)
-        )
+        raise api.BatchError(
+            f"{len(errors)} of {len(chunks)} chunk(s) failed to store:", errors
+        ) from errors[0][1]
 
     return
 

{cwms_python-1.1.0 → cwms_python-1.1.2}/cwms/users/users.py

@@ -1,4 +1,3 @@
-import json
 from typing import Any, List, Optional
 
 import cwms.api as api
@@ -14,7 +13,7 @@ def _raise_user_management_error(error: api.ApiError, action: str) -> None:
             "are not authorized for user-management access or are missing the "
             f"required role assignment. CDA responded with 403 {response_hint}."
         )
-        raise api.PermissionError(error.response, message) from None
+        raise api.PermissionError(error.response, message) from error
     raise error
 
 
@@ -110,7 +109,7 @@ def get_user(user_name: str) -> dict[str, Any]:
         if status_code == 404:
             raise api.NotFoundError(
                 error.response, f"User '{user_name}' was not found."
-            ) from None
+            ) from error
         if status_code == 403:
             _raise_user_management_error(error, f"User '{user_name}' retrieval")
         raise
@@ -153,15 +152,10 @@ def delete_user_roles(user_name: str, office_id: str, roles: List[str]) -> None:
         raise ValueError("Delete user roles requires a roles list")
 
     endpoint = f"user/{user_name}/roles/{office_id}"
-    headers = {"accept": "*/*", "Content-Type": api.api_version_text(api.API_VERSION)}
-    # TODO: Delete does not currently support a body in the api module. Use SESSION directly
-    with api.SESSION.delete(
-        endpoint, headers=headers, data=json.dumps(roles)
-    ) as response:
-        if not response.ok:
-            _raise_user_management_error(
-                api.ApiError(response), f"User '{user_name}' role deletion"
-            )
+    try:
+        api.delete(endpoint, data=roles)
+    except api.ApiError as error:
+        _raise_user_management_error(error, f"User '{user_name}' role deletion")
 
 
 def update_user(user_name: str, office_id: str, roles: List[str]) -> None:

{cwms_python-1.1.0 → cwms_python-1.1.2}/pyproject.toml

@@ -3,7 +3,7 @@ name = "cwms-python"
 repository = "https://github.com/HydrologicEngineeringCenter/cwms-python"
 
 # Managed by Release Please; runtime versions come from package metadata.
-version = "1.1.0"
+version = "1.1.2"
 
 packages = [
     { include = "cwms" },