oceanarray 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

oceanarray/__init__.py

@@ -4,10 +4,23 @@ This package provides functions for processing, quality control, and analysis
 of oceanographic time series data from moorings and instruments.
 """
 
+try:
+    # Written by setuptools-scm at build time (gitignored); the live version.
+    from oceanarray._version import __version__
+except ImportError:  # pragma: no cover - source tree with no build artefact
+    try:
+        from importlib.metadata import PackageNotFoundError as _PNF
+        from importlib.metadata import version as _v
+
+        __version__ = _v("oceanarray")
+    except _PNF:  # pragma: no cover
+        __version__ = "0.0.0"
+
 from oceanarray.config import parameters
 from oceanarray.processors import process
 
 __all__ = [
+    "__version__",
     # Subpackages (canonical locations)
     "analysis",
     "config",

oceanarray/_version.py

@@ -1 +1 @@
-__version__ = '0.2.0'
+__version__ = '0.4.0'

oceanarray/analysis/clock.py

@@ -12,7 +12,7 @@ Naming conventions updated from the original module:
 - file suffix ``_raw`` → ``_stage2``
 """
 
-import os
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
@@ -53,13 +53,13 @@ def load_mooring_instruments(
     proc_dir = output_path + mooring_name
     moor_yaml = proc_dir + "/" + mooring_name + ".mooring.yaml"
 
-    with open(moor_yaml, "r") as f:
+    with Path(moor_yaml).open() as f:
         moor_yaml_data = yaml.safe_load(f)
 
     # Support both new key 'clamp' and legacy key 'instruments'
     instrument_list = moor_yaml_data.get("clamp", moor_yaml_data.get("instruments", []))
     if not instrument_list:
-        raise KeyError(  # noqa: TRY003
+        raise KeyError(
             f"Mooring YAML {moor_yaml} has neither 'clamp' nor 'instruments' key."
         )
 
@@ -68,7 +68,7 @@ def load_mooring_instruments(
         fname = mooring_name + "_" + str(i["serial"]) + file_suffix + ".nc"
         rawfile = proc_dir + "/" + i["instrument"] + "/" + fname
 
-        if os.path.exists(rawfile):
+        if Path(rawfile).exists():
             print(rawfile)
             ds1 = xr.open_dataset(rawfile)
 
@@ -123,9 +123,7 @@ def create_common_time_grid(datasets):
         latest_end = np.datetime64("NaT", "ns")
 
     dt_sec = int(np.nanmedian(intervals_min) * 60)
-    time_grid = np.arange(earliest_start, latest_end, np.timedelta64(dt_sec, "s"))
-
-    return time_grid
+    return np.arange(earliest_start, latest_end, np.timedelta64(dt_sec, "s"))
 
 
 def interpolate_datasets_to_grid(datasets, time_grid):
@@ -251,7 +249,7 @@ def combine_interpolated_datasets(datasets_interp):
             co = 0
         clock_offsets.append(int(np.rint(co)) if np.isfinite(co) else 0)
 
-    combined_ds = xr.Dataset(
+    return xr.Dataset(
         data_vars=combined_data,
         coords={
             "time": time_coord,
@@ -263,8 +261,6 @@ def combine_interpolated_datasets(datasets_interp):
         },
     )
 
-    return combined_ds
-
 
 def analyze_deployment_timing(combined_ds):
     """Analyze deployment timing using temperature-based detection of deployment periods.
@@ -319,7 +315,7 @@ def calculate_timing_offsets(combined_ds, bin_width_sec=60):
     # Find consensus group
     vals = start_off0[np.isfinite(start_off0)]
     if vals.size == 0:
-        raise RuntimeError("No finite start offsets to form consensus.")  # noqa: TRY003
+        raise RuntimeError("No finite start offsets to form consensus.")
 
     vmin, vmax = vals.min(), vals.max()
     bins = np.arange(vmin - bin_width_sec, vmax + 2 * bin_width_sec, bin_width_sec)
@@ -539,6 +535,7 @@ def print_correlation_summary(combined_ds, correlation_results):
             correlation_results["lags"],
             correlation_results["max_correlations"],
             correlation_results["clock_offsets"],
+            strict=False,
         )
     ):
         print(
@@ -626,7 +623,9 @@ def plot_deployment_boundaries(
             continue
 
         # Plot each boundary
-        for ax, title, idx, time_ref in zip(axes, titles, indices, times_ref):
+        for ax, title, idx, time_ref in zip(
+            axes, titles, indices, times_ref, strict=False
+        ):
             # Define range around the boundary
             start_range = max(0, idx - n_samples)
             end_range = min(len(time_orig), idx + n_samples + 1)

oceanarray/analysis/hydrographic.py

@@ -9,10 +9,10 @@ Pairs with :mod:`oceanarray.plotters.hydrography` for figure output.
 
 from __future__ import annotations
 
+import gsw
 import numpy as np
 import pandas as pd
 import xarray as xr
-import gsw
 
 
 def calc_psal(ds: xr.Dataset) -> xr.Dataset:
@@ -99,7 +99,9 @@ def find_cold_entry_exit(
     starts = np.r_[idx[0], idx[1:][gaps]]
     ends = np.r_[idx[:-1][gaps], idx[-1]]
 
-    runs = [(s, e) for s, e in zip(starts, ends) if (e - s + 1) >= min_len]
+    runs = [
+        (s, e) for s, e in zip(starts, ends, strict=False) if (e - s + 1) >= min_len
+    ]
     if not runs:
         return None, None, thr
 
@@ -111,7 +113,7 @@ def find_cold_entry_exit(
 def calc_ds_difference(ds1: xr.Dataset, ds2: xr.Dataset) -> xr.Dataset:
     """Compute the variable-by-variable difference between two time-matched datasets."""
     if not np.array_equal(ds1["TIME"].values, ds2["TIME"].values):
-        raise ValueError("TIME grids do not match between datasets.")  # noqa: TRY003
+        raise ValueError("TIME grids do not match between datasets.")
 
     # Variables to exclude from differencing
     exclude_vars = {"YY", "MM", "DD", "HH"}
@@ -261,11 +263,11 @@ def isopycnal_dataset(
 
     """
     if sigma_var not in ds:
-        raise ValueError(f"sigma variable '{sigma_var}' not found in dataset")  # noqa: TRY003
+        raise ValueError(f"sigma variable '{sigma_var}' not found in dataset")
 
     da = ds[sigma_var]
     if "time" not in da.dims or "pressure" not in da.dims:
-        raise ValueError(  # noqa: TRY003
+        raise ValueError(
             f"'{sigma_var}' must have both 'time' and 'pressure' dimensions"
         )
     da_tp = da.transpose("time", "pressure")

oceanarray/analysis/science.py

@@ -57,8 +57,7 @@ def flag_salinity_outliers(ds: xr.Dataset, n_std: float = 4) -> xr.DataArray:
     lower = mean_sal - n_std * std_sal
     upper = mean_sal + n_std * std_sal
 
-    flag = (ds["PSAL"] < lower) | (ds["PSAL"] > upper)
-    return flag
+    return (ds["PSAL"] < lower) | (ds["PSAL"] > upper)
 
 
 def flag_temporal_spikes(
@@ -87,8 +86,7 @@ def flag_vertical_inconsistencies(
     vert_diff = np.abs(ds[var].diff("DEPTH"))
     # Pad to match original dimensions
     vert_diff = vert_diff.reindex(DEPTH=ds["DEPTH"], method="ffill")
-    flag = vert_diff > threshold
-    return flag
+    return vert_diff > threshold
 
 
 def run_qc(ds: xr.Dataset) -> xr.Dataset:
@@ -172,10 +170,10 @@ def process_dataset(
 
     # Apply region of interest mask
     mask = (
-        (LAT >= latlim[0])
-        & (LAT <= latlim[1])
-        & (LON >= lonlim[0])
-        & (LON <= lonlim[1])
+        (latlim[0] <= LAT)
+        & (latlim[1] >= LAT)
+        & (lonlim[0] <= LON)
+        & (lonlim[1] >= LON)
     )
     TEMP_profiles = TEMP_profiles[mask]
     PSAL_profiles = PSAL_profiles[mask]
@@ -194,7 +192,7 @@ def process_dataset(
     standard_pressures = pgrid.flatten()
 
     # Create ds_standard
-    ds_standard = xr.Dataset(
+    return xr.Dataset(
         {
             "CT": ((time_dim, pres_dim), CT_standard),
             "SA": ((time_dim, pres_dim), SA_standard),
@@ -209,18 +207,20 @@ def process_dataset(
         },
     )
 
-    return ds_standard
-
 
 # ---------------------------------------------------------------------------
 # Backward-compat re-exports — import directly from the new modules in new code
 # ---------------------------------------------------------------------------
-from .temporal import lag_correlation, split_value, downsample_to_sparse  # noqa: F401, E402
-from .spectral import compute_cwt, welch_psd, welch_psd_gapaware  # noqa: F401, E402
 from .hydrographic import (  # noqa: F401, E402
+    calc_ds_difference,
     calc_psal,
     find_cold_entry_exit,
-    calc_ds_difference,
-    isopycnal_pressure_series,
     isopycnal_dataset,
+    isopycnal_pressure_series,
+)
+from .spectral import compute_cwt, welch_psd, welch_psd_gapaware  # noqa: F401, E402
+from .temporal import (  # noqa: F401, E402
+    downsample_to_sparse,
+    lag_correlation,
+    split_value,
 )

oceanarray/analysis/spectral.py

@@ -61,14 +61,14 @@ def gonella_rotary_spectrum(
     """
     from scipy.signal import csd as _scipy_csd
 
-    _kw: dict = dict(
-        fs=fs,
-        window="hann",
-        nperseg=nperseg,
-        noverlap=noverlap,
-        detrend="linear",
-        scaling="density",
-    )
+    _kw: dict = {
+        "fs": fs,
+        "window": "hann",
+        "nperseg": nperseg,
+        "noverlap": noverlap,
+        "detrend": "linear",
+        "scaling": "density",
+    }
     f_uu, p_uu = _scipy_welch(u_col, **_kw)
     _, p_vv = _scipy_welch(v_col, **_kw)
     _, c_uv = _scipy_csd(u_col, v_col, **_kw)
@@ -139,7 +139,7 @@ def compute_cwt(
     try:
         import pycwt
     except ImportError as exc:
-        raise ImportError(  # noqa: TRY003
+        raise ImportError(
             "pycwt is required for wavelet analysis: pip install pycwt"
         ) from exc
 
@@ -205,7 +205,7 @@ def compute_cwt(
         gap_starts = np.where(edge_diff == 1)[0]
         gap_ends = np.where(edge_diff == -1)[0]
         t_all = np.arange(n, dtype=float)
-        for s, e in zip(gap_starts, gap_ends):
+        for s, e in zip(gap_starts, gap_ends, strict=False):
             eff_coi[s:e] = 0.0  # entire gap column is unreliable
             # Distance (samples) to the nearer gap boundary, outside the gap
             dist = np.minimum(
@@ -322,7 +322,7 @@ def welch_psd_gapaware(
     freq_out: np.ndarray | None = None
     psd_sum: np.ndarray | None = None
     total_wins = 0
-    for s, e in zip(starts, ends):
+    for s, e in zip(starts, ends, strict=False):
         seg = x[s:e]
         if len(seg) < segment_length:
             continue

oceanarray/analysis/temporal.py

@@ -97,7 +97,7 @@ def lag_correlation(
     x = np.asarray(x, float)
     y = np.asarray(y, float)
     if x.shape != y.shape:
-        raise ValueError("x and y must have same length (subsample both).")  # noqa: TRY003
+        raise ValueError("x and y must have same length (subsample both).")
     corrs = np.full(2 * max_lag + 1, np.nan)
     for k, lag in enumerate(range(-max_lag, max_lag + 1)):
         if lag < 0:
@@ -154,7 +154,7 @@ def split_value(data: np.ndarray, nbins: int = 30) -> float:
 
     # Step 3: Find minimum between first two major peaks
     if len(peaks) < 2:
-        raise ValueError(  # noqa: TRY003
+        raise ValueError(
             f"split_value: fewer than 2 histogram peaks found in data "
             f"(found {len(peaks)}). Data may be unimodal or nbins={nbins} too coarse."
         )