cleaned up some tests and some lint, and few issues AI identified.

Author: ChrisBarker-NOAA

gridded/depth.py

@@ -1,4 +1,4 @@
-import os
+
 import warnings
 
 import numpy as np
@@ -8,11 +8,7 @@
 from gridded.utilities import (
     can_create_class,
     get_dataset,
-    merge_var_search_dicts,
     parse_filename_dataset_args,
-    search_dataset_for_any_long_name,
-    search_dataset_for_variables_by_longname,
-    search_dataset_for_variables_by_varname,
     search_netcdf_vars,
 )
 
@@ -258,7 +254,8 @@ def interpolation_alphas(
         indices = np.ma.MaskedArray(data=idxs, mask=np.zeros((len(idxs)), dtype=bool))
 
         alphas = np.ma.MaskedArray(
-            data=np.empty((len(points)), dtype=np.float64) * np.nan, mask=np.zeros((len(points)), dtype=bool)
+            data=np.full((len(points),), np.nan, dtype=np.float64),
+            mask=np.zeros((len(points)), dtype=bool)
         )
 
         # set above surface and below seafloor alphas to allow future filtering
@@ -295,7 +292,7 @@ def interpolation_alphas(
 
         alphas[within_layer] = (depths[within_layer] - L0) / (L1 - L0)
 
-        if any(np.isnan(alphas)):
+        if np.isnan(alphas).any():
             raise ValueError("Some alphas are still unmasked and NaN. Please file a bug report")
 
         return indices, alphas
@@ -491,7 +488,9 @@ def from_netCDF(
                     time = Time.constant_time()
                 else:
                     time = Time.from_netCDF(
-                        dataset=zeta_var._grp,  # zeta_var should be a netCDF4.Variable, so its _grp attribute should be the dataset it belongs to
+                        # zeta_var should be a netCDF4.Variable,
+                        # so its _grp attribute should be the dataset it belongs to
+                        dataset=zeta_var._grp,
                         datavar=zeta_var,
                         origin=time_origin,
                         displacement=displacement,
@@ -675,13 +674,18 @@ def interpolation_alphas(
         # if data_shape[0] == self.num_layers:
         #    raise NotImplementedError('Interpolation of data on depth layers not supported yet')
 
-        depth_profiles = self.get_depth_profile(points, time, data_shape=data_shape, _hash=_hash, extrapolate=extrapolate)
+        depth_profiles = self.get_depth_profile(points,
+                                                time,
+                                                data_shape=data_shape,
+                                                _hash=_hash,
+                                                extrapolate=extrapolate)
 
         indices = np.ma.MaskedArray(
             data=-np.ones((len(points)), dtype=np.int64) * 1000, mask=np.zeros((len(points)), dtype=bool)
         )
         alphas = np.ma.MaskedArray(
-            data=np.empty((len(points)), dtype=np.float64) * np.nan, mask=np.zeros((len(points)), dtype=bool)
+            data=np.full((len(points)), np.nan, dtype=np.float64),
+            mask=np.zeros((len(points)), dtype=bool)
         )
 
         # use np.digitize to bin the depths into the layers.
@@ -779,10 +783,16 @@ def _apply_boundary_conditions(
         alphas.mask = np.logical_or(alphas.mask, exclusion_mask)
         return indices, alphas, oob_mask
 
-
-    def get_s_coordinate(self, points, time, data_shape=None, _hash=None, **kwargs):
+    def get_s_coordinate(self,
+                         points,
+                         time,
+                         data_shape=None,
+                         _hash=None,
+                         **kwargs):
         """
-        Given an array of points and a time, returns the S-Coordinate values of the depth layers at those points and time.
+        Given an array of points and a time, returns the S-Coordinate values
+        of the depth layers at those points and time.
+
         :param points: array of points to interpolate to
         :type points: numpy array of shape (n, 3)
 
@@ -794,7 +804,8 @@ def get_s_coordinate(self, points, time, data_shape=None, _hash=None, **kwargs):
                            index on the sigma layers or levels.
         :type data_shape: tuple of int
 
-        :return: numpy array of shape (n, num_w_levels) of n s-coordinate depth_profiles. 0 reference is mean sea surface.
+        :return: numpy array of shape (n, num_w_levels) of n s-coordinate
+                 depth_profiles. 0 reference is mean sea surface.
         """
         raise NotImplementedError("get_s_coordinate not implemented for S_Depth, required in subclasses")
 
@@ -812,7 +823,8 @@ def get_depth_profile(self, points, time, data_shape=None, _hash=None, **kwargs)
                            index on the sigma layers or levels.
         :type data_shape: tuple of int
 
-        :return: numpy array of shape (n, num_w_levels) of n depth_profiles, referenced to the surface (i.e. surface is 0, seafloor is negative)
+        :return: numpy array of shape (n, num_w_levels) of n depth_profiles,
+                 referenced to the surface (i.e. surface is 0, seafloor is negative)
         """
         z = self.zeta.at(points, time, unmask=False, _hash=_hash, **kwargs)
         return self.get_s_coordinate(points, time, data_shape=data_shape, _hash=_hash, **kwargs) + z

gridded/tests/test_depth.py

@@ -531,14 +531,20 @@ def get_database_nc():
     """
     L_depth_file = os.path.join(TEST_DATA, "test_L_Depth.nc")
 
-    ncfile = nc.Dataset(L_depth_file)
-    ds = gridded.Dataset(L_depth_file)
+    # ncfile = nc.Dataset(L_depth_file)
+#    ds = gridded.Dataset(L_depth_file)
+    ds = gridded.Dataset.from_netCDF(L_depth_file)
     depth = gridded.depth.Depth.from_netCDF(filename=L_depth_file)
-    time = gridded.time.Time.from_netCDF(filename=L_depth_file, datavar=ncfile["u"])
+    # what's going on here? We shouldn't have to separately get time?
+    # after a dataset is loaded?
+    # but even if so, why not let Time.from_netCDF load the variable?
+    # time = gridded.time.Time.from_netCDF(filename=L_depth_file, datavar=ncfile["u"])
+    time = gridded.time.Time.from_netCDF(filename=L_depth_file, varname="time")
 
     return time, depth, ds
 
 
+
 class Test_L_Depth:
     def test_construction(self, get_l_depth):