Linting

Author: eleanorfrajka

oceanarray/mooring.py

@@ -4,34 +4,34 @@
 import pandas as pd
 from scipy.interpolate import interp1d
 
+
 def filter_all_time_vars(ds):
     """
     Return a copy of ds with all data variables of length TIME lowpass filtered.
     """
     # Get sampling rate from TIME (assume TIME is in seconds or has a uniform spacing)
-    time = ds['TIME']
-    dt = (time[1] - time[0]) / np.timedelta64(1, 's')  # seconds
+    time = ds["TIME"]
+    dt = (time[1] - time[0]) / np.timedelta64(1, "s")  # seconds
     sr = 1.0 / dt  # Hz
 
     # 2 day cutoff frequency in Hz
     co = 1.0 / (2 * 24 * 3600)  # 2 days in seconds
 
     ds_filt = ds.copy(deep=True)
     for var in ds.data_vars:
-        if 'TIME' in ds[var].dims and ds[var].sizes['TIME'] == ds['TIME'].size:
+        if "TIME" in ds[var].dims and ds[var].sizes["TIME"] == ds["TIME"].size:
             y = ds[var].values
-            filtered = tools.auto_filt(y, sr, co, typ='low', fo=6)
+            filtered = tools.auto_filt(y, sr, co, typ="low", fo=6)
             ds_filt[var].values = filtered
     return ds_filt
 
 
-
 def get_12hourly_time_grid(
     time_or_ds,
-    freq='12h',
+    freq="12h",
     start_offset=pd.Timedelta(days=1),
     end_offset=pd.Timedelta(0),
-    time_var='TIME'
+    time_var="TIME",
 ):
     """
     Given a pandas.DatetimeIndex, array of datetimes, or xarray.Dataset,
@@ -63,40 +63,52 @@ def get_12hourly_time_grid(
         time = pd.to_datetime(time_or_ds)
     start = time[0]
     stop = time[-1]
-    start_day = (start + start_offset).normalize() if start.time() != pd.Timestamp('00:00').time() else start.normalize()
+    start_day = (
+        (start + start_offset).normalize()
+        if start.time() != pd.Timestamp("00:00").time()
+        else start.normalize()
+    )
     stop_day = (stop - end_offset).normalize()
     jd_grid = pd.date_range(start=start_day, end=stop_day, freq=freq)
     return jd_grid
 
+
 def interp_to_12hour_grid(ds1):
     jd_grid = get_12hourly_time_grid(ds1)
-    time1 = ds1['TIME'].values
+    time1 = ds1["TIME"].values
 
-    vars_to_interp = [v for v in ds1.data_vars if ds1[v].shape == ds1['TIME'].shape]
-    for v in ['YY', 'MM', 'DD', 'HH']:
+    vars_to_interp = [v for v in ds1.data_vars if ds1[v].shape == ds1["TIME"].shape]
+    for v in ["YY", "MM", "DD", "HH"]:
         if v in vars_to_interp:
             vars_to_interp.remove(v)
 
     interp_vars = {}
     for var in vars_to_interp:
-        interp_func = interp1d(time1.astype('datetime64[s]').astype(float), ds1[var].values, bounds_error=False, fill_value='extrapolate')
-        interp_vars[var] = interp_func(jd_grid.values.astype('datetime64[s]').astype(float))
+        interp_func = interp1d(
+            time1.astype("datetime64[s]").astype(float),
+            ds1[var].values,
+            bounds_error=False,
+            fill_value="extrapolate",
+        )
+        interp_vars[var] = interp_func(
+            jd_grid.values.astype("datetime64[s]").astype(float)
+        )
 
     ds_interp = xr.Dataset(
-        {var: (['TIME'], interp_vars[var]) for var in interp_vars},
-        coords={'TIME': jd_grid}
+        {var: (["TIME"], interp_vars[var]) for var in interp_vars},
+        coords={"TIME": jd_grid},
     )
     # Copy attributes from ds1
     ds_interp.attrs = ds1.attrs.copy()
 
     # Add singleton variables (variables with no TIME dimension)
     for var in ds1.data_vars:
-        if 'TIME' not in ds1[var].dims:
+        if "TIME" not in ds1[var].dims:
             ds_interp[var] = ds1[var]
 
     # Also copy over coordinates that are not 'TIME'
     for coord in ds1.coords:
-        if coord != 'TIME' and coord not in ds_interp.coords:
+        if coord != "TIME" and coord not in ds_interp.coords:
             ds_interp = ds_interp.assign_coords({coord: ds1[coord]})
 
     return ds_interp

oceanarray/rodb.py

@@ -219,7 +219,6 @@ def rodbload(filepath, variables: list[str] = None) -> xr.Dataset:
 }
 
 
-
 def format_latlon(value, is_lat=True):
     deg = int(abs(value))
     minutes = (abs(value) - deg) * 60

oceanarray/tools.py

@@ -1,7 +1,6 @@
 import logging
 import numpy as np
 import xarray as xr
-import numpy as np
 from scipy.signal import butter, filtfilt
 
 # Initialize logging
@@ -42,7 +41,7 @@
 }
 
 
-def auto_filt(y, sr, co, typ='low', fo=6):
+def auto_filt(y, sr, co, typ="low", fo=6):
     """
     Apply a Butterworth digital filter to a data array.
 

tests/test_instrument.py

@@ -4,17 +4,24 @@
 from datetime import datetime
 from pathlib import Path
 
-from oceanarray.instrument import apply_microcat_calibration_from_txt, stage2_trim, trim_suggestion
-from oceanarray.instrument import apply_microcat_calibration_from_txt
+from oceanarray.instrument import (
+    apply_microcat_calibration_from_txt,
+    stage2_trim,
+    trim_suggestion,
+)
 from oceanarray.rodb import rodbload
 
+
 def test_trim_suggestion_basic():
     time = pd.date_range("2020-01-01", periods=10, freq="h")
-    ds = xr.Dataset({
-        "T": ("TIME", [0]*3 + [10]*4 + [0]*3),
-        "C": ("TIME", [0]*3 + [12]*4 + [0]*3),
-        "P": ("TIME", [0]*3 + [8]*4 + [0]*3),
-    }, coords={"TIME": time})
+    ds = xr.Dataset(
+        {
+            "T": ("TIME", [0] * 3 + [10] * 4 + [0] * 3),
+            "C": ("TIME", [0] * 3 + [12] * 4 + [0] * 3),
+            "P": ("TIME", [0] * 3 + [8] * 4 + [0] * 3),
+        },
+        coords={"TIME": time},
+    )
 
     start, end = trim_suggestion(ds, percent=80, threshold=5)
 
@@ -36,31 +43,44 @@ def test_stage2_trim_single_sample():
 
 def test_apply_microcat_with_flags(tmp_path):
     txt = tmp_path / "mock.microcat.txt"
-    txt.write_text("""Conductivity: 1.0 2.0
+    txt.write_text(
+        """Conductivity: 1.0 2.0
 Temperature: -0.5 0.5
 Pressure: 0.0 1.0
 Average conductivity applied? y
 Average temperature applied? y
 Average pressure applied? n
-""")
+"""
+    )
 
     # Create dummy .use file
     time = pd.date_range("2022-01-01", periods=3, freq="h")
-    ds = xr.Dataset({"T": ("TIME", [10.0, 11.0, 12.0]),
-                     "C": ("TIME", [35.0, 35.1, 35.2]),
-                     "P": ("TIME", [1000.0, 1001.0, 1002.0])},
-                    coords={"TIME": time})
+    ds = xr.Dataset(
+        {
+            "T": ("TIME", [10.0, 11.0, 12.0]),
+            "C": ("TIME", [35.0, 35.1, 35.2]),
+            "P": ("TIME", [1000.0, 1001.0, 1002.0]),
+        },
+        coords={"TIME": time},
+    )
     use_path = tmp_path / "mock.use"
     ds.to_netcdf(use_path)  # write as .nc, simulate reading in `rodbload`
 
     # Patch rodbload to return this dataset
     from oceanarray import instrument
+
     instrument.rodb.rodbload = lambda _: ds
 
     ds_cal = apply_microcat_calibration_from_txt(txt, use_path)
-    assert "T" in ds_cal and np.allclose(ds_cal["T"].values, [10.0 + 0.0, 11.0 + 0.0, 12.0 + 0.0], atol=1e-6)
-    assert "C" in ds_cal and np.allclose(ds_cal["C"].values, [36.5, 36.6, 36.7], atol=1e-6)
-    assert "P" in ds_cal and np.allclose(ds_cal["P"].values, [1000.0, 1001.0, 1002.0], atol=1e-6)  # unchanged
+    assert "T" in ds_cal and np.allclose(
+        ds_cal["T"].values, [10.0 + 0.0, 11.0 + 0.0, 12.0 + 0.0], atol=1e-6
+    )
+    assert "C" in ds_cal and np.allclose(
+        ds_cal["C"].values, [36.5, 36.6, 36.7], atol=1e-6
+    )
+    assert "P" in ds_cal and np.allclose(
+        ds_cal["P"].values, [1000.0, 1001.0, 1002.0], atol=1e-6
+    )  # unchanged
 
 
 def test_apply_microcat_calibration_from_txt(tmp_path):

tests/test_mooring.py

@@ -1,26 +1,28 @@
 import numpy as np
 import pandas as pd
 import xarray as xr
-import pytest
-from oceanarray.mooring import get_12hourly_time_grid, filter_all_time_vars  # Adjust import as needed
-from oceanarray import tools  # Assuming auto_filt is defined here
+from oceanarray.mooring import (
+    get_12hourly_time_grid,
+    filter_all_time_vars,
+)  # Adjust import as needed
+
+from oceanarray.mooring import interp_to_12hour_grid
 
-from oceanarray.mooring import interp_to_12hour_grid, get_12hourly_time_grid
 
 def test_interp_to_12hour_grid():
     # Create a synthetic dataset
     time = pd.date_range("2020-01-01", periods=48, freq="h")  # hourly for 2 days
     data = np.sin(np.linspace(0, 2 * np.pi, len(time)))  # sinusoidal signal
-    attrs = {'platform': 'testmoor'}
+    attrs = {"platform": "testmoor"}
 
     ds = xr.Dataset(
         {
             "T": ("TIME", data),
             "sal": ("TIME", data * 2),
-            "const": ("DEPTH", [1.0, 2.0])
+            "const": ("DEPTH", [1.0, 2.0]),
         },
         coords={"TIME": time, "DEPTH": [10, 20]},
-        attrs=attrs
+        attrs=attrs,
     )
 
     # Run interpolation
@@ -46,13 +48,16 @@ def test_interp_to_12hour_grid():
     assert "DEPTH" in ds_interp.coords
     np.testing.assert_array_equal(ds_interp["DEPTH"], ds["DEPTH"])
 
+
 def test_filter_all_time_vars_lowpass_behavior():
     # Create a synthetic signal: high-frequency + low-frequency component
     time = pd.date_range("2020-01-01", periods=240, freq="h")  # 10-day hourly record
     t_seconds = (time - time[0]).total_seconds().values
 
     low_freq_signal = np.sin(2 * np.pi * t_seconds / (4 * 24 * 3600))  # 4-day period
-    high_freq_noise = 0.5 * np.sin(2 * np.pi * t_seconds / (12 * 3600))  # 12-hour period
+    high_freq_noise = 0.5 * np.sin(
+        2 * np.pi * t_seconds / (12 * 3600)
+    )  # 12-hour period
     signal = low_freq_signal + high_freq_noise
 
     ds = xr.Dataset(
@@ -88,7 +93,7 @@ def test_filter_all_time_vars_ignores_non_time_vars():
             "var1": ("TIME", np.sin(np.linspace(0, 10, 48))),
             "scalar": ((), 5.0),
         },
-        coords={"TIME": time}
+        coords={"TIME": time},
     )
 
     ds_filtered = filter_all_time_vars(ds)
@@ -104,7 +109,9 @@ def test_get_12hourly_time_grid_with_array():
     expected_end = pd.Timestamp("2020-01-05T00:00")
     assert grid[0] == expected_start
     assert grid[-1] == expected_end
-    assert (grid.freq == pd.tseries.frequencies.to_offset("12h")) or (grid.freqstr == "12h")
+    assert (grid.freq == pd.tseries.frequencies.to_offset("12h")) or (
+        grid.freqstr == "12h"
+    )
 
 
 def test_get_12hourly_time_grid_with_dataset():
@@ -117,7 +124,9 @@ def test_get_12hourly_time_grid_with_dataset():
 
 def test_get_12hourly_time_grid_custom_offset():
     times = pd.date_range("2023-07-01T00:00", "2023-07-03T23:59", freq="1h")
-    grid = get_12hourly_time_grid(times, start_offset=pd.Timedelta(hours=0), end_offset=pd.Timedelta(days=1))
+    grid = get_12hourly_time_grid(
+        times, start_offset=pd.Timedelta(hours=0), end_offset=pd.Timedelta(days=1)
+    )
     assert grid[0] == pd.Timestamp("2023-07-01T00:00")
     assert grid[-1] == pd.Timestamp("2023-07-02T00:00")
 

tests/test_plotters.py

@@ -61,13 +61,16 @@ def test_plot_microcat_handles_time_format():
     assert isinstance(formatter, mdates.DateFormatter)
     assert formatter.fmt == "%Y.%b"
 
+
 def test_plot_trim_windows_creates_figaxes():
     import numpy as np
     import xarray as xr
     from oceanarray import plotters
     from datetime import datetime, timedelta
 
-    time = np.array([np.datetime64(datetime(2023, 1, 1) + timedelta(hours=i)) for i in range(48)])
+    time = np.array(
+        [np.datetime64(datetime(2023, 1, 1) + timedelta(hours=i)) for i in range(48)]
+    )
     data = np.random.random(48)
     ds = xr.Dataset(
         {
@@ -84,6 +87,7 @@ def test_plot_trim_windows_creates_figaxes():
     assert fig is not None
     assert axes.shape == (3, 2)
 
+
 def test_plot_microcat_generates_expected_plot():
     import numpy as np
     import xarray as xr
@@ -105,6 +109,7 @@ def test_plot_microcat_generates_expected_plot():
     fig = plotters.plot_microcat(ds)
     assert fig is not None
 
+
 def test_show_variables_on_xarray_dataset():
     import numpy as np
     import xarray as xr
@@ -125,6 +130,7 @@ def test_show_variables_on_xarray_dataset():
     html = styled.to_html()
     assert "<table" in html  # crude but effective confirmation
 
+
 def test_show_attributes_from_dataset():
     import xarray as xr
     from oceanarray import plotters