Merge branch 'main' into split_at

Author: jay-hennen

.github/workflows/conda_test.yml

@@ -0,0 +1,24 @@
+name: Linting
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    name: linting
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v7
+
+    - name: Set up Pixi Environment
+      uses: prefix-dev/setup-pixi@v0.10.0
+      with:
+        cache: true
+        manifest-path: py_gnome/pixi.toml
+        environments: dev312
+
+    - name: Lint
+      working-directory: py_gnome
+#      continue-on-error: true
+      run: pixi run lint

.github/workflows/lint.yml

@@ -9,18 +9,19 @@ on:
 jobs:
   test:
     strategy:
+      fail-fast: false
       # Test against multiple environments (e.g., different Python versions)
       matrix:
         environment: [test312, test313, test314]
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-15-intel]
     runs-on: ${{ matrix.os }}
 
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
 
       - name: Setup Pixi
-        uses: prefix-dev/setup-pixi@v0.8.3
+        uses: prefix-dev/setup-pixi@v0.10.0
         with:
           # Specify which environment from your pixi.toml to install
           environments: ${{ matrix.environment }}

.github/workflows/pixi_test.yml

@@ -1,10 +1,18 @@
 # generated test files
-*noncompliant_sgrid.nc
-*sgrid_deltares.nc
-*sgrid_deltares_no_opt_attr.nc
-*sgrid_roms.nc
-*sgrid_wrf.nc
-*sgrid_wrf_2.nc
+# NOTE: if we need these, they should be in a
+#       defined place, and ignored in a tests/.gitignore file
+# *noncompliant_sgrid.nc
+# *sgrid_deltares.nc
+# *sgrid_deltares_no_opt_attr.nc
+# *sgrid_roms.nc
+# *sgrid_wrf.nc
+# *sgrid_wrf_2.nc
+
+# version file (auto-generated)
+gridded/_version.py
+
+# version file (auto-generated)
+gridded/_version.py
 
 # OS-X stuff
 .DS_Store

.gitignore

@@ -0,0 +1,2 @@
+sphinx>=8.2.3
+sphinx-rtd-theme

docs/conda_requirements_docs.txt

@@ -65,17 +65,17 @@ The user can now plot the time series for a given location and times, without ha
 Duck Typing
 -----------
 
-The Grid objects (Grid, Time, Depth) are for the most part "duck typed", rather than strict subclassing. Though there are base classes that provide shared functionality.
+The Grid objects (Grid, Time, Depth) are for the most part "duck typed", rather than strict subclassing, though there are base classes that provide shared functionality.
 
-We are trying to be clear about the "public" vs "private" API by using leading underscores for methods and attributes not intended for external use.
+We are trying to be clear about the "public" vs "private" API by using leading underscores for methods and attributes not intended for external use, but it's not as consitent as it should be.
 
 
 Lazy loading / data arrays
 --------------------------
 
 Many of the datasets users need to work with can be quite large. As a result it is impractical to load entire datasets into memory at once. ``gridded`` for the most part shifts the burden of handling lazy loading to external libraries, and does this by keeping data stored in a "numpy array-like" objects. Users can use pure numpy arrays, or any object that "acts" like a numpy array. This should allow ``gridded`` to work with netcdf variables, hdf5 arrays, dask arrays, etc.
 
-In practice, there is no clear definition of "array-like", so ``gridded`` has defined its own definition, based on features we know we need. But it is assumed that nd indexing behaves that same as numpy arrays -- as there is no way to easily confirm that. This is a goal, but in fact, only numpy arrays and ``netCDF4 Variables`` have been implimented and tested. In the future, we may use ``xarray`` as a single abstration layer, rather than rolling our own.
+In practice, there is no clear definition of "array-like", so ``gridded`` has defined its own definition, based on features we know we need. But it is assumed that nd indexing behaves that same as numpy arrays -- as there is no way to easily confirm that. This is a goal, but in fact, only numpy arrays and ``netCDF4 Variables`` have been implemented and tested. In the future, we may use ``xarray`` as a single abstraction layer, rather than rolling our own.
 
 To support that, we support converting and testing for array-like with:
 
@@ -85,7 +85,7 @@ and
 
 ``gridded.utils.isarraylike()``
 
-Those utilities will be updated as new needs arrise.
+Those utilities will be updated as new needs arise.
 
 Reference
 =========

docs/source/api_reference.rst

@@ -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,
     interpolate_rho_to_psi,
 )
@@ -259,7 +255,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
@@ -296,7 +293,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
@@ -423,16 +420,18 @@ def from_netCDF(
 
         :param terms: Direct mapping of component name to netCDF variable name. Use
                       this if auto detection fails. Partial definition is allowable.
-                      Unspecified terms will use the value in `.default_names`.
-                      ::
-                        {'Cs_r': 'Cs_r',
-                         'Cs_w': 'Cs_w',
-                         's_rho': 's_rho'),
-                         's_w': 's_w',
-                         'bathymetry': 'h',
-                         'hc': 'hc'),
-                         'zeta': 'zeta')
-                         }
+                      Unspecified terms will use the value in `.default_names`. ::
+
+                        {
+                        'Cs_r': 'Cs_r',
+                        'Cs_w': 'Cs_w',
+                        's_rho': 's_rho'),
+                        's_w': 's_w',
+                        'bathymetry': 'h',
+                        'hc': 'hc'),
+                        'zeta': 'zeta')
+                        }
+
         :type terms: dict
 
         :param name: Human-readable name for this object
@@ -490,7 +489,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,
@@ -678,7 +679,8 @@ def interpolation_alphas(
             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.
@@ -771,14 +773,21 @@ def _apply_boundary_conditions(
         if bottom_boundary_condition == "mask":
             indices.mask[below_bottom_mask] = True
             alphas.mask[below_bottom_mask] = True
-            
+
         indices.mask = np.logical_or(indices.mask, exclusion_mask)
         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)
 
@@ -790,7 +799,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")
 
@@ -808,7 +818,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/depth.py

@@ -77,6 +77,8 @@ def __init__(self, ncfile=None, grid=None, variables=None, grid_topology=None, a
         else:  # Create from grid and variables -- this is what should usually happen.
             self.filename = None
             self.grid = grid
+            self.time = None
+            self.depth = None
             self.variables = {} if variables is None else variables
             self.attributes = {} if attributes is None else attributes
 
@@ -93,7 +95,9 @@ def _init_from_netCDF(self, filename=None, grid_file=None, variable_files=None,
 
         self.nc_dataset = get_dataset(filename)
         self.filename = self.nc_dataset.filepath()
-        self.grid = Grid.from_netCDF(filename=self.filename, dataset=self.nc_dataset, grid_topology=grid_topology)
+        self.grid = Grid.from_netCDF(filename=self.filename,
+                                     dataset=self.nc_dataset,
+                                     grid_topology=grid_topology)
         # fixme: this should load the depth and time, and then the variables.
         self.variables = self._variables_from_netCDF(self.nc_dataset)
         self.attributes = get_dataset_attrs(self.nc_dataset)
@@ -102,7 +106,7 @@ def _init_from_netCDF(self, filename=None, grid_file=None, variable_files=None,
     def from_netCDF(cls, filename=None, grid_file=None, variable_files=None, grid_topology=None):
         """
         NOTE: only loading from a single file is currently implemented.
-              you can create a DATaset by hand, by loading the grid and
+              you can create a Dataset by hand, by loading the grid and
               variables separately, and then adding them
 
         load a gridded.Dataset from a netCDF file

gridded/gridded.py

@@ -254,7 +254,7 @@ def info(self):
 
     def get_all_face_padding(self):
         if self.face_padding is not None:
-            all_face_padding = self.face_padding
+            all_face_padding = self._face_padding
         else:
             all_face_padding = []
         return all_face_padding
@@ -270,7 +270,7 @@ def get_all_edge_padding(self):
     def all_padding(self):
         all_padding = self.get_all_face_padding() + self.get_all_edge_padding()
         if self.vertical_padding is not None:
-            all_padding += self.vertical_padding
+            all_padding += self._vertical_padding
         return all_padding
 
     def save_as_netcdf(self, filepath):
@@ -313,9 +313,12 @@ def node_padding(self, val):
         self._node_padding = val
 
     @property
-    def center_padding(self):
-        if hasattr(self, "_center_padding") and self._center_padding:
-            return self._center_padding
+    def face_padding(self):
+        if hasattr(self, "_face_padding") and self._face_padding:
+            if isinstance(self._face_padding[0], GridPadding):
+                return (self._face_padding[0].padding, self._face_padding[1].padding)
+            else:
+                return self._face_padding
         elif hasattr(self, "center_lon") and self.center_lon is not None:
             face_shape = self.center_lon.shape
             node_shape = self.node_lon.shape
@@ -329,9 +332,17 @@ def center_padding(self):
         else:
             return (None, None)
 
+    @face_padding.setter
+    def face_padding(self, val):
+        self._face_padding = val
+
+    @property
+    def center_padding(self):
+        return self.face_padding
+
     @center_padding.setter
     def center_padding(self, val):
-        self._center_padding = val
+        self._face_padding = val
 
     @property
     def edge1_padding(self):
@@ -361,6 +372,20 @@ def edge2_padding(self):
     def edge2_padding(self, val):
         self._edge2_padding = val
 
+    @property
+    def vertical_padding(self):
+        if hasattr(self, "_vertical_padding") and self._vertical_padding:
+            if isinstance(self._vertical_padding[0], GridPadding):
+                return (None, self._vertical_padding[0].padding)
+            else:
+                return self._vertical_padding
+        else:
+            return (None, self.center_padding[1])
+
+    @vertical_padding.setter
+    def vertical_padding(self, val):
+        self._vertical_padding = val
+
     def infer_location(self, variable):
         """
         Assuming default is psi grid, check variable dimensions to determine which grid