Remove shorthand import numpy as np

Author: mx-moth

docs/developing/grass.py

@@ -3,7 +3,7 @@
 from functools import cached_property
 from typing import Optional, Tuple, Dict
 
-import numpy as np
+import numpy
 import xarray
 from shapely.geometry import Polygon
 from shapely.geometry.base import BaseGeometry
@@ -95,12 +95,12 @@ def selector_for_index(self, index: GrassIndex) -> Dict[str, int]:
         return {'warp': warp, 'weft': weft}
 
     @cached_property
-    def polygons(self) -> np.ndarray:
+    def polygons(self) -> numpy.ndarray:
         def make_polygon_for_cell(warp: int, weft: int) -> Polygon:
             # Implementation left as an exercise for the reader
             return Polygon(...)
 
-        return np.array([
+        return numpy.array([
             make_polygon_for_cell(warp, weft)
             for warp in range(self.dataset.dimensions['warp'])
             for weft in range(self.dataset.dimensions['weft'])

src/emsarray/compat/shapely.py

@@ -1,7 +1,7 @@
 import warnings
 from typing import Generic, Iterable, Tuple, TypeVar, Union, cast
 
-import numpy as np
+import numpy
 import shapely
 from packaging.version import parse
 from shapely.errors import ShapelyDeprecationWarning
@@ -23,16 +23,16 @@ class SpatialIndex(Generic[T]):
     This also handles the version differences in STRtree between
     shapely ~= 1.8.x and shapely >= 2.0.0
     """
-    items: np.ndarray
+    items: numpy.ndarray
     index: STRtree
 
-    dtype: np.dtype = np.dtype([('geom', np.object_), ('data', np.object_)])
+    dtype: numpy.dtype = numpy.dtype([('geom', numpy.object_), ('data', numpy.object_)])
 
     def __init__(
         self,
-        items: Union[np.ndarray, Iterable[Tuple[BaseGeometry, T]]],
+        items: Union[numpy.ndarray, Iterable[Tuple[BaseGeometry, T]]],
     ):
-        self.items = np.array(items, dtype=self.dtype)
+        self.items = numpy.array(items, dtype=self.dtype)
 
         if shapely_version >= v2:
             self.index = STRtree(self.items['geom'])
@@ -46,19 +46,19 @@ def __init__(
     def query(
         self,
         geom: BaseGeometry,
-    ) -> np.ndarray:
+    ) -> numpy.ndarray:
         if shapely_version >= v2:
             indices = self.index.query(geom)
         else:
             indices = self.index._query(geom)
-        return cast(np.ndarray, self.items.take(indices))
+        return cast(numpy.ndarray, self.items.take(indices))
 
     def nearest(
         self,
         geom: BaseGeometry,
-    ) -> np.ndarray:
+    ) -> numpy.ndarray:
         if shapely_version >= v2:
             indices = self.index.nearest(geom)
         else:
             indices = self.index._nearest(geom)
-        return cast(np.ndarray, self.items.take(indices))
+        return cast(numpy.ndarray, self.items.take(indices))

src/emsarray/conventions/_base.py

@@ -11,7 +11,7 @@
     List, Optional, Tuple, TypeVar, Union, cast
 )
 
-import numpy as np
+import numpy
 import xarray
 from shapely import unary_union
 from shapely.geometry import MultiPolygon, Point, Polygon
@@ -355,7 +355,7 @@ def get_time_name(self) -> Hashable:
                 # A time variable must have units of the form '<units> since <epoc>'
                 if 'since' in units:
                     # The variable must now be a numpy datetime
-                    if variable.dtype.type == np.datetime64:
+                    if variable.dtype.type == numpy.datetime64:
                         return name
         raise NoSuchCoordinateError("Could not find time coordinate in dataset")
 
@@ -441,7 +441,7 @@ def get_all_depth_names(self) -> List[Hashable]:
         ),
         DeprecationWarning,
     )
-    def get_depths(self) -> np.ndarray:
+    def get_depths(self) -> numpy.ndarray:
         """Get the depth of each vertical layer in this dataset.
 
         .. deprecated:: 0.5.0
@@ -453,7 +453,7 @@ def get_depths(self) -> np.ndarray:
         :class:`numpy.ndarray`
             An array of depths, one per vertical layer in the dataset.
         """
-        return cast(np.ndarray, self.depth_coordinate.values)
+        return cast(numpy.ndarray, self.depth_coordinate.values)
 
     @utils.deprecated(
         (
@@ -462,7 +462,7 @@ def get_depths(self) -> np.ndarray:
         ),
         DeprecationWarning,
     )
-    def get_times(self) -> np.ndarray:
+    def get_times(self) -> numpy.ndarray:
         """Get all timesteps in this dataset.
 
         .. deprecated:: 0.5.0
@@ -476,7 +476,7 @@ def get_times(self) -> np.ndarray:
             The datetimes will be whatever native format the dataset uses,
             likely :class:`numpy.datetime64`.
         """
-        return cast(np.ndarray, self.time_coordinate.values)
+        return cast(numpy.ndarray, self.time_coordinate.values)
 
     @abc.abstractmethod
     def ravel_index(self, index: Index) -> int:
@@ -940,7 +940,7 @@ def make_poly_collection(
             values = data_array.values[self.mask]
             kwargs['array'] = values
             if 'clim' not in kwargs:
-                kwargs['clim'] = (np.nanmin(values), np.nanmax(values))
+                kwargs['clim'] = (numpy.nanmin(values), numpy.nanmax(values))
 
         if 'transform' not in kwargs:
             kwargs['transform'] = self.data_crs
@@ -988,15 +988,15 @@ def make_quiver(
         """
         from matplotlib.quiver import Quiver
 
-        x, y = np.transpose(self.face_centres)
+        x, y = numpy.transpose(self.face_centres)
 
         # A Quiver needs some values when being initialized.
         # We don't always want to provide values to the quiver,
         # sometimes preferring to fill them in later,
         # so `u` and `v` are optional.
-        # If they are not provided, we set default quiver values of `np.nan`.
-        values: Union[Tuple[np.ndarray, np.ndarray], Tuple[float, float]]
-        values = np.nan, np.nan
+        # If they are not provided, we set default quiver values of `numpy.nan`.
+        values: Union[Tuple[numpy.ndarray, numpy.ndarray], Tuple[float, float]]
+        values = numpy.nan, numpy.nan
 
         if u is not None and v is not None:
             u, v = self._get_data_array(u), self._get_data_array(v)
@@ -1024,7 +1024,7 @@ def make_quiver(
 
     @property
     @abc.abstractmethod
-    def polygons(self) -> np.ndarray:
+    def polygons(self) -> numpy.ndarray:
         """A :class:`numpy.ndarray` of :class:`shapely.Polygon` instances
         representing the cells in this dataset.
 
@@ -1047,7 +1047,7 @@ def polygons(self) -> np.ndarray:
         pass
 
     @cached_property
-    def face_centres(self) -> np.ndarray:
+    def face_centres(self) -> numpy.ndarray:
         """
         A numpy :class:`~numpy.ndarray` of face centres, which are (x, y) pairs.
         The first dimension will be the same length and in the same order
@@ -1057,14 +1057,14 @@ def face_centres(self) -> np.ndarray:
         # This default implementation simply finds the centroid of each polygon.
         # Subclasses are free to override this if the particular convention and dataset
         # provides the cell centres as a data array.
-        centres = np.array([
-            polygon.centroid.coords[0] if polygon is not None else [np.nan, np.nan]
+        centres = numpy.array([
+            polygon.centroid.coords[0] if polygon is not None else [numpy.nan, numpy.nan]
             for polygon in self.polygons
         ])
-        return cast(np.ndarray, centres)
+        return cast(numpy.ndarray, centres)
 
     @cached_property
-    def mask(self) -> np.ndarray:
+    def mask(self) -> numpy.ndarray:
         """
         A boolean :class:`numpy.ndarray` indicating which cells have valid polygons.
         This can be used to select only items from linear arrays
@@ -1081,10 +1081,10 @@ def mask(self) -> np.ndarray:
         --------
         :meth:`Convention.make_linear`
         """
-        mask = np.fromiter(
+        mask = numpy.fromiter(
             (p is not None for p in self.polygons),
             dtype=bool, count=self.polygons.size)
-        return cast(np.ndarray, mask)
+        return cast(numpy.ndarray, mask)
 
     @cached_property
     def geometry(self) -> Union[Polygon, MultiPolygon]:

src/emsarray/conventions/arakawa_c.py

@@ -13,7 +13,7 @@
 from functools import cached_property
 from typing import Dict, Hashable, List, Optional, Tuple, cast
 
-import numpy as np
+import numpy
 import xarray
 from shapely.geometry.base import BaseGeometry
 from xarray.core.dataset import DatasetCoordinates
@@ -74,7 +74,7 @@ def shape(self) -> Tuple[int, int]:
     @cached_property
     def size(self) -> int:
         """The size of this grid, ``j * i``."""
-        return cast(int, np.prod(self.shape))
+        return cast(int, numpy.prod(self.shape))
 
     def __repr__(self) -> str:
         bits = (f"{key}: {value!r}" for key, value in [
@@ -260,13 +260,13 @@ def unravel_index(
         if grid_kind is None:
             grid_kind = ArakawaCGridKind.face
         topology = self._topology_for_grid_kind[grid_kind]
-        j, i = map(int, np.unravel_index(index, topology.shape))
+        j, i = map(int, numpy.unravel_index(index, topology.shape))
         return (grid_kind, j, i)
 
     def ravel_index(self, indices: ArakawaCIndex) -> int:
         grid_kind, j, i = indices
         topology = self._topology_for_grid_kind[grid_kind]
-        return int(np.ravel_multi_index((j, i), topology.shape))
+        return int(numpy.ravel_multi_index((j, i), topology.shape))
 
     def get_grid_kind_and_size(self, data_array: xarray.DataArray) -> Tuple[ArakawaCGridKind, int]:
         dims = set(data_array.dims)
@@ -280,12 +280,12 @@ def get_grid_kind_and_size(self, data_array: xarray.DataArray) -> Tuple[ArakawaC
 
     @cached_property
     @utils.timed_func
-    def polygons(self) -> np.ndarray:
+    def polygons(self) -> numpy.ndarray:
         # Make an array of shape (j, i, 2) of all the nodes
-        grid = np.stack([self.node.longitude.values, self.node.latitude.values], axis=-1)
+        grid = numpy.stack([self.node.longitude.values, self.node.latitude.values], axis=-1)
 
         # Transform this in to an array of shape (topology.size, 4, 2)
-        points = np.stack([
+        points = numpy.stack([
             grid[:-1, :-1],
             grid[:-1, +1:],
             grid[+1:, +1:],
@@ -295,12 +295,12 @@ def polygons(self) -> np.ndarray:
         return utils.make_polygons_with_holes(points)
 
     @cached_property
-    def face_centres(self) -> np.ndarray:
-        centres = np.column_stack((
+    def face_centres(self) -> numpy.ndarray:
+        centres = numpy.column_stack((
             self.make_linear(self.face.longitude).values,
             self.make_linear(self.face.latitude).values,
         ))
-        return cast(np.ndarray, centres)
+        return cast(numpy.ndarray, centres)
 
     def selector_for_index(self, index: ArakawaCIndex) -> Dict[Hashable, int]:
         kind, j, i = index
@@ -342,7 +342,7 @@ def make_clip_mask(
             item.linear_index
             for polygon, item in self.spatial_index.query(clip_geometry)
             if polygon.intersects(clip_geometry)]
-        face_mask = np.full(self.face.shape, fill_value=False)
+        face_mask = numpy.full(self.face.shape, fill_value=False)
         face_mask.ravel()[intersecting_indices] = True
 
         # Expand the mask by one cell around the clipped region, as a buffer
@@ -357,7 +357,7 @@ def apply_clip_mask(self, clip_mask: xarray.Dataset, work_dir: Pathish) -> xarra
 
 
 def c_mask_from_centres(
-    face_mask: np.ndarray,
+    face_mask: numpy.ndarray,
     dimensions: ArakawaCDimensions,
     coords: Optional[DatasetCoordinates] = None,
 ) -> xarray.Dataset: