rastr 0.5.0__tar.gz → 0.6.0__tar.gz

{rastr-0.5.0 → rastr-0.6.0}/.github/workflows/ci.yml

@@ -1,7 +1,6 @@
 name: CI
 permissions:
   contents: read
-  pull-requests: write
 on:
   workflow_dispatch:
   push:
@@ -21,12 +20,15 @@ concurrency:
   cancel-in-progress: true
 jobs:
   tests:
+    name: Run Tests and Checks
     runs-on: ${{ matrix.os }}
     env:
       PYTHONIOENCODING: utf-8
     steps:
       - name: Checkout code
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
 
       - name: Setup git user config
         run: |
@@ -41,8 +43,10 @@ jobs:
 
       - name: Setup Python
         run: |
-          uv python pin ${{ matrix.python-version }}
+          uv python pin ${PYTHON_VERSION}
           uv python install
+        env:
+          PYTHON_VERSION: ${{ matrix.python-version }}
 
       - name: Run pre-commit
         if: matrix.checks
@@ -54,6 +58,13 @@ jobs:
         run: |
           uv run pyright
 
+      - name: Run zizmor
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
+        run: |
+          uv run zizmor --no-progress --pedantic .github/
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Run pytest
         uses: pavelzw/pytest-action@510c5e90c360a185039bea56ce8b3e7e51a16507 # v2.2.0
         if: matrix.pytest
@@ -92,6 +103,8 @@ jobs:
     name: Analyse Code Quality
     runs-on: ubuntu-latest
     needs: tests
+    permissions:
+      pull-requests: write # SonarQube needs to post comments on PRs
     if: always() && needs.tests.result == 'success'
 
     steps:
@@ -99,6 +112,7 @@ jobs:
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0 # Shallow clones should be disabled for better relevancy of analysis
+          persist-credentials: false
 
       - name: Download coverage reports
         uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
@@ -110,7 +124,7 @@ jobs:
       - name: Create SonarQube properties
         run: |
           cat > sonar-project.properties << EOF
-          sonar.projectKey=${{ vars.SONAR_PROJECT_KEY }}
+          sonar.projectKey=${SONAR_PROJECT_KEY}
           sonar.language=py
           sonar.python.version=3.13
           sonar.sources=./src
@@ -119,9 +133,11 @@ jobs:
           sonar.exclusions=**/Dockerfile,**/notebooks/**,**/scripts/**
           sonar.verbose=false
           EOF
+        env:
+          SONAR_PROJECT_KEY: ${{ vars.SONAR_PROJECT_KEY }}
 
       - name: Run SonarQube analysis
-        uses: SonarSource/sonarqube-scan-action@884b79409bbd464b2a59edc326a4b77dc56b2195 # v3.1.0
+        uses: SonarSource/sonarqube-scan-action@fd88b7d7ccbaefd23d8f36f73b59db7a3d246602 # v6.0.0
         env:
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
           SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}

rastr-0.6.0/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release to PyPI
+permissions:
+  contents: read
+on:
+  push:
+    tags:
+      - "v*"
+jobs:
+  deploy:
+    name: Release on PyPI
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write # This is necessary to use trusted publishing with uv
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@3b9817b1bf26186f03ab8277bab9b827ea5cc254 # v3.2.0
+        with:
+          version: "0.7.13" # Sync with pyproject.toml
+          enable-cache: false
+
+      - name: "Set up Python"
+        uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
+        with:
+          python-version: 3.13
+
+      - name: Release
+        run: |
+          uv build
+          uv publish --trusted-publishing always

{rastr-0.5.0 → rastr-0.6.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rastr
-Version: 0.5.0
+Version: 0.6.0
 Summary: Geospatial Raster datatype library for Python.
 Project-URL: Source Code, https://github.com/tonkintaylor/rastr
 Project-URL: Bug Tracker, https://github.com/tonkintaylor/rastr/issues
 Project-URL: Releases, https://github.com/tonkintaylor/rastr/releases
-Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/fde05e3c098da7ff9e77a37332d55fb7dbacd873.zip
+Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/a1b755ea9cde7f81b2963dcb12917090019f2b47.zip
 Author-email: Tonkin & Taylor Limited <Sub-DisciplineData+AnalyticsStaff@tonkintaylor.co.nz>, Nathan McDougall <nmcdougall@tonkintaylor.co.nz>, Ben Karl <bkarl@tonkintaylor.co.nz>
 License-Expression: MIT
 License-File: LICENSE
@@ -77,8 +77,8 @@ from rastr.create import full_raster
 from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
-# Create an example raster
-raster = Raster.example()
+# Read a raster from a file
+raster = Raster.read_file("path/to/raster.tif")
 
 # Basic arithmetic operations
 doubled = raster * 2

{rastr-0.5.0 → rastr-0.6.0}/README.md

@@ -43,8 +43,8 @@ from rastr.create import full_raster
 from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
-# Create an example raster
-raster = Raster.example()
+# Read a raster from a file
+raster = Raster.read_file("path/to/raster.tif")
 
 # Basic arithmetic operations
 doubled = raster * 2

{rastr-0.5.0 → rastr-0.6.0}/pyproject.toml

@@ -66,6 +66,7 @@ dev = [
   "ruff>=0.13.2",
   "tqdm>=4.67.1",
   "usethis>=0.15.2",
+  "zizmor>=1.14.2",
 ]
 test = [
   "coverage[toml]>=7.10.1",
@@ -263,6 +264,6 @@ root_packages = [ "rastr" ]
 [[tool.importlinter.contracts]]
 name = "rastr"
 type = "layers"
-layers = [ "create | io", "raster", "meta", "arr | gis", "_version" ]
+layers = [ "create : io : raster", "meta", "arr | gis", "_version" ]
 containers = [ "rastr" ]
 exhaustive = true

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/arr/fill.py

@@ -8,7 +8,7 @@ if TYPE_CHECKING:
     from numpy.typing import NDArray
 
 
-def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
+def fillna_nearest_neighbours(arr: NDArray) -> NDArray:
     """Fill NaN values in an N-dimensional array with their nearest neighbours' values.
 
     The nearest neighbour is determined using the Euclidean distance between array
@@ -28,4 +28,5 @@ def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
     # Interpolate at the array indices
     interp = NearestNDInterpolator(nonnan_idxs, arr[nonnan_mask])
     filled_arr = interp(*np.indices(arr.shape))
-    return filled_arr
+    # Preserve the original dtype
+    return filled_arr.astype(arr.dtype)

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/create.py

@@ -16,7 +16,7 @@ from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Collection, Iterable
 
     import geopandas as gpd
     from numpy.typing import ArrayLike
@@ -141,7 +141,7 @@ def rasterize_gdf(
     gdf: gpd.GeoDataFrame,
     *,
     raster_meta: RasterMeta,
-    target_cols: list[str],
+    target_cols: Collection[str],
 ) -> list[Raster]:
     """Rasterize geometries from a GeoDataFrame.
 
@@ -212,7 +212,9 @@ def rasterize_gdf(
     return rasters
 
 
-def _validate_columns_exist(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> None:
+def _validate_columns_exist(
+    gdf: gpd.GeoDataFrame, target_cols: Collection[str]
+) -> None:
     """Validate that all target columns exist in the GeoDataFrame.
 
     Args:
@@ -228,7 +230,9 @@ def _validate_columns_exist(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> No
         raise MissingColumnsError(msg)
 
 
-def _validate_columns_numeric(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> None:
+def _validate_columns_numeric(
+    gdf: gpd.GeoDataFrame, target_cols: Collection[str]
+) -> None:
     """Validate that all target columns contain numeric data.
 
     Args:

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/gis/fishnet.py

@@ -41,8 +41,20 @@ def get_point_grid_shape(
     """Calculate the shape of the point grid based on bounds and cell size."""
 
     xmin, ymin, xmax, ymax = bounds
-    ncols = int(np.ceil((xmax - xmin) / cell_size))
-    nrows = int(np.ceil((ymax - ymin) / cell_size))
+    ncols_exact = (xmax - xmin) / cell_size
+    nrows_exact = (ymax - ymin) / cell_size
+
+    # Use round for values very close to integers to avoid floating-point
+    # sensitivity while maintaining ceil behavior for truly fractional values
+    if np.isclose(ncols_exact, np.round(ncols_exact)):
+        ncols = int(np.round(ncols_exact))
+    else:
+        ncols = int(np.ceil(ncols_exact))
+
+    if np.isclose(nrows_exact, np.round(nrows_exact)):
+        nrows = int(np.round(nrows_exact))
+    else:
+        nrows = int(np.ceil(nrows_exact))
 
     return nrows, ncols
 

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/gis/smooth.py

@@ -5,7 +5,7 @@ Fork + Port of <https://github.com/philipschall/shapelysmooth> (Public domain)
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, TypeAlias
+from typing import TYPE_CHECKING, TypeVar
 
 import numpy as np
 from shapely.geometry import LineString, Polygon
@@ -14,7 +14,7 @@ from typing_extensions import assert_never
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-T: TypeAlias = LineString | Polygon
+T = TypeVar("T", bound=LineString | Polygon)
 
 
 class InputeTypeError(TypeError):
@@ -38,12 +38,12 @@ def catmull_rom_smooth(geometry: T, alpha: float = 0.5, subdivs: int = 10) -> T:
     coords, interior_coords = _get_coords(geometry)
     coords_smoothed = _catmull_rom(coords, alpha=alpha, subdivs=subdivs)
     if isinstance(geometry, LineString):
-        return type(geometry)(coords_smoothed)
+        return geometry.__class__(coords_smoothed)
     elif isinstance(geometry, Polygon):
         interior_coords_smoothed = [
             _catmull_rom(c, alpha=alpha, subdivs=subdivs) for c in interior_coords
         ]
-        return type(geometry)(coords_smoothed, holes=interior_coords_smoothed)
+        return geometry.__class__(coords_smoothed, holes=interior_coords_smoothed)
     else:
         assert_never(geometry)
 

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/io.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 import numpy as np
 import rasterio
@@ -14,28 +14,48 @@ from rastr.raster import Raster
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
+R = TypeVar("R", bound=Raster)
+
 
 def read_raster_inmem(
-    raster_path: Path | str, *, crs: CRS | str | None = None
-) -> Raster:
-    """Read raster data from a file and return an in-memory Raster object."""
+    raster_path: Path | str,
+    *,
+    crs: CRS | str | None = None,
+    cls: type[R] = Raster,
+) -> R:
+    """Read raster data from a file and return an in-memory Raster object.
+
+    Args:
+        raster_path: Path to the raster file.
+        crs: Optional CRS to override the raster's native CRS.
+        cls: The Raster subclass to instantiate. This is mostly for internal use,
+             but can be useful if you have a custom `Raster` subclass.
+    """
     crs = CRS.from_user_input(crs) if crs is not None else None
 
     with rasterio.open(raster_path, mode="r") as dst:
         # Read the entire array
-        arr: NDArray[np.float64] = dst.read()
-        arr = arr.squeeze().astype(np.float64)
+        raw_arr: NDArray = dst.read()
+        raw_arr = raw_arr.squeeze()
+
         # Extract metadata
         cell_size = dst.res[0]
         if crs is None:
             crs = CRS.from_user_input(dst.crs)
         transform = dst.transform
         nodata = dst.nodata
+
+        # Cast integers to float16 to handle NaN values
+        if np.issubdtype(raw_arr.dtype, np.integer):
+            arr = raw_arr.astype(np.float16)
+        else:
+            arr = raw_arr
+
         if nodata is not None:
-            arr[arr == nodata] = np.nan
+            arr[raw_arr == nodata] = np.nan
 
     raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
-    raster_obj = Raster(arr=arr, raster_meta=raster_meta)
+    raster_obj = cls(arr=arr, raster_meta=raster_meta)
     return raster_obj
 
 
@@ -81,10 +101,16 @@ def read_raster_mosaic_inmem(
             crs = CRS.from_user_input(sources[0].crs)
 
         nodata = sources[0].nodata
-        if nodata is not None:
-            arr[arr == nodata] = np.nan
+        raw_arr = arr.squeeze()
 
-        arr = arr.squeeze().astype(np.float64)
+        # Cast integers to float16 to handle NaN values
+        if np.issubdtype(raw_arr.dtype, np.integer):
+            arr = raw_arr.astype(np.float16)
+        else:
+            arr = raw_arr
+
+        if nodata is not None:
+            arr[raw_arr == nodata] = np.nan
 
         raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
         raster_obj = Raster(arr=arr, raster_meta=raster_meta)

{rastr-0.5.0 → rastr-0.6.0}/src/rastr/raster.py

@@ -108,6 +108,16 @@ class Raster(BaseModel):
         """Set the transform via meta."""
         self.meta.transform = value
 
+    @property
+    def cell_size(self) -> float:
+        """Convenience property to access the cell size via meta."""
+        return self.meta.cell_size
+
+    @cell_size.setter
+    def cell_size(self, value: float) -> None:
+        """Set the cell size via meta."""
+        self.meta.cell_size = value
+
     def __init__(
         self,
         *,
@@ -663,8 +673,15 @@ class Raster(BaseModel):
 
         return raster_gdf
 
-    def to_file(self, path: Path | str) -> None:
-        """Write the raster to a GeoTIFF file."""
+    def to_file(self, path: Path | str, **kwargs: Any) -> None:
+        """Write the raster to a GeoTIFF file.
+
+        Args:
+            path: Path to output file.
+            **kwargs: Additional keyword arguments to pass to `rasterio.open()`. If
+                      `nodata` is provided, NaN values in the raster will be replaced
+                      with the nodata value.
+        """
 
         path = Path(path)
 
@@ -679,6 +696,15 @@ class Raster(BaseModel):
             msg = f"Unsupported file extension: {suffix}"
             raise ValueError(msg)
 
+        # Handle nodata: use provided value or default to np.nan
+        if "nodata" in kwargs:
+            # Replace NaN values with the nodata value
+            nodata_value = kwargs.pop("nodata")
+            arr_to_write = np.where(np.isnan(self.arr), nodata_value, self.arr)
+        else:
+            nodata_value = np.nan
+            arr_to_write = self.arr
+
         with rasterio.open(
             path,
             "w",
@@ -689,10 +715,11 @@ class Raster(BaseModel):
             dtype=self.arr.dtype,
             crs=self.raster_meta.crs,
             transform=self.raster_meta.transform,
-            nodata=np.nan,
+            nodata=nodata_value,
+            **kwargs,
         ) as dst:
             try:
-                dst.write(self.arr, 1)
+                dst.write(arr_to_write, 1)
             except CPLE_BaseError as err:
                 msg = f"Failed to write raster to file: {err}"
                 raise OSError(msg) from err
@@ -719,6 +746,34 @@ class Raster(BaseModel):
         raster_meta = RasterMeta.example()
         return cls(arr=arr, raster_meta=raster_meta)
 
+    @classmethod
+    def full_like(cls, other: Raster, *, fill_value: float) -> Self:
+        """Create a raster with the same metadata as another but filled with a constant.
+
+        Args:
+            other: The raster to copy metadata from.
+            fill_value: The constant value to fill all cells with.
+
+        Returns:
+            A new raster with the same shape and metadata as `other`, but with all cells
+            set to `fill_value`.
+        """
+        arr = np.full(other.shape, fill_value, dtype=np.float32)
+        return cls(arr=arr, raster_meta=other.raster_meta)
+
+    @classmethod
+    def read_file(cls, filename: Path | str, crs: CRS | str | None = None) -> Self:
+        """Read raster data from a file and return an in-memory Raster object.
+
+        Args:
+            filename: Path to the raster file.
+            crs: Optional coordinate reference system to override the file's CRS.
+        """
+        # Import here to avoid circular import (rastr.io imports Raster)
+        from rastr.io import read_raster_inmem  # noqa: PLC0415
+
+        return read_raster_inmem(filename, crs=crs, cls=cls)
+
     @overload
     def apply(
         self,
@@ -819,6 +874,16 @@ class Raster(BaseModel):
         new_raster.arr = filled_arr
         return new_raster
 
+    def copy(self) -> Self:  # type: ignore[override]
+        """Create a copy of the raster.
+
+        This method wraps `model_copy()` for convenience.
+
+        Returns:
+            A new Raster instance.
+        """
+        return self.model_copy(deep=True)
+
     def get_xy(self) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
         """Get the x and y coordinates of the raster cell centres in meshgrid format.
 
@@ -835,7 +900,7 @@ class Raster(BaseModel):
         return coords[:, :, 0], coords[:, :, 1]
 
     def contour(
-        self, levels: list[float] | NDArray, *, smoothing: bool = True
+        self, levels: Collection[float] | NDArray, *, smoothing: bool = True
     ) -> gpd.GeoDataFrame:
         """Create contour lines from the raster data, optionally with smoothing.
 
@@ -848,8 +913,8 @@ class Raster(BaseModel):
         contouring, to denoise the contours.
 
         Args:
-            levels: A list or array of contour levels to generate. The contour lines
-                    will be generated for each level in this sequence.
+            levels: A collection or array of contour levels to generate. The contour
+                    lines will be generated for each level in this sequence.
             smoothing: Defaults to true, which corresponds to applying a smoothing
                        algorithm to the contour lines. At the moment, this is the
                        Catmull-Rom spline algorithm. If set to False, the raw
@@ -905,19 +970,40 @@ class Raster(BaseModel):
         # Dissolve contours by level to merge all contour lines of the same level
         return contour_gdf.dissolve(by="level", as_index=False)
 
-    def blur(self, sigma: float) -> Self:
+    def blur(self, sigma: float, *, preserve_nan: bool = True) -> Self:
         """Apply a Gaussian blur to the raster data.
 
         Args:
             sigma: Standard deviation for Gaussian kernel, in units of geographic
                    coordinate distance (e.g. meters). A larger sigma results in a more
                    blurred image.
+            preserve_nan: If True, applies NaN-safe blurring by extrapolating NaN values
+                          before blurring and restoring them afterwards. This prevents
+                          NaNs from spreading into valid data during the blur operation.
         """
         from scipy.ndimage import gaussian_filter
 
         cell_sigma = sigma / self.raster_meta.cell_size
 
-        blurred_array = gaussian_filter(self.arr, sigma=cell_sigma)
+        if preserve_nan:
+            # Save the original NaN mask
+            nan_mask = np.isnan(self.arr)
+
+            # If there are no NaNs, just apply regular blur
+            if not np.any(nan_mask):
+                blurred_array = gaussian_filter(self.arr, sigma=cell_sigma)
+            else:
+                # Extrapolate to fill NaN values temporarily
+                extrapolated_arr = fillna_nearest_neighbours(arr=self.arr)
+
+                # Apply blur to the extrapolated array
+                blurred_array = gaussian_filter(extrapolated_arr, sigma=cell_sigma)
+
+                # Restore original NaN values
+                blurred_array = np.where(nan_mask, np.nan, blurred_array)
+        else:
+            blurred_array = gaussian_filter(self.arr, sigma=cell_sigma)
+
         new_raster = self.model_copy()
         new_raster.arr = blurred_array
         return new_raster
@@ -1175,29 +1261,27 @@ class Raster(BaseModel):
 
         return raster
 
-    def trim_nan(self) -> Self:
-        """Crop the raster by trimming away all-NaN slices at the edges.
+    def _trim_value(self, *, value_mask: NDArray[np.bool_], value_name: str) -> Self:
+        """Crop the raster by trimming away slices matching the mask at the edges.
 
-        This effectively trims the raster to the smallest bounding box that contains all
-        of the non-NaN values. Note that this does not guarantee no NaN values at all
-        around the edges, only that there won't be entire edges which are all-NaN.
-
-        Consider using `.extrapolate()` for further cleanup of NaN values.
+        Args:
+            value_mask: Boolean mask where True indicates values to trim
+            value_name: Name of the value type for error messages (e.g., 'NaN', 'zero')
         """
         arr = self.arr
 
-        # Check if the entire array is NaN
-        if np.all(np.isnan(arr)):
-            msg = "Cannot crop raster: all values are NaN"
+        # Check if the entire array matches the mask
+        if np.all(value_mask):
+            msg = f"Cannot crop raster: all values are {value_name}"
             raise ValueError(msg)
 
-        # Find rows and columns that are not all NaN
-        nan_row_mask = np.all(np.isnan(arr), axis=1)
-        nan_col_mask = np.all(np.isnan(arr), axis=0)
+        # Find rows and columns that are not all matching the mask
+        row_mask = np.all(value_mask, axis=1)
+        col_mask = np.all(value_mask, axis=0)
 
         # Find the bounding indices
-        (row_indices,) = np.where(~nan_row_mask)
-        (col_indices,) = np.where(~nan_col_mask)
+        (row_indices,) = np.where(~row_mask)
+        (col_indices,) = np.where(~col_mask)
 
         min_row, max_row = row_indices[0], row_indices[-1]
         min_col, max_col = col_indices[0], col_indices[-1]
@@ -1220,6 +1304,26 @@ class Raster(BaseModel):
 
         return self.__class__(arr=cropped_arr, raster_meta=new_meta)
 
+    def trim_nan(self) -> Self:
+        """Crop the raster by trimming away all-NaN slices at the edges.
+
+        This effectively trims the raster to the smallest bounding box that contains all
+        of the non-NaN values. Note that this does not guarantee no NaN values at all
+        around the edges, only that there won't be entire edges which are all-NaN.
+
+        Consider using `.extrapolate()` for further cleanup of NaN values.
+        """
+        return self._trim_value(value_mask=np.isnan(self.arr), value_name="NaN")
+
+    def trim_zeros(self) -> Self:
+        """Crop the raster by trimming away all-zero slices at the edges.
+
+        This effectively trims the raster to the smallest bounding box that contains all
+        of the non-zero values. Note that this does not guarantee no zero values at all
+        around the edges, only that there won't be entire edges which are all-zero.
+        """
+        return self._trim_value(value_mask=(self.arr == 0), value_name="zero")
+
     def resample(
         self, new_cell_size: float, *, method: Literal["bilinear"] = "bilinear"
     ) -> Self:
@@ -1307,11 +1411,11 @@ def _get_vmin_vmax(
             category=RuntimeWarning,
         )
         if vmin is None:
-            _vmin = raster.min()
+            _vmin = float(raster.min())
         else:
             _vmin = vmin
         if vmax is None:
-            _vmax = raster.max()
+            _vmax = float(raster.max())
         else:
             _vmax = vmax