ncplot 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

ncplot/command_line.py

@@ -3,6 +3,7 @@ from ncplot import view
 import sys
 import re
 import os
+import glob
 
 def is_url(x):
     regex = re.compile(
@@ -19,23 +20,29 @@ def is_url(x):
 
 
 def main():
+    """
+    The ``ncplot`` command: view the files, URLs or glob patterns it is given.
+    Returns a message (which ``sys.exit`` prints, exiting with status 1) if
+    there is nothing to view.
+    """
     if len(sys.argv) == 1:
         return "Please supply a file"
 
+    ff = []
     for x in sys.argv[1:]:
-        if os.path.exists(x):
-            ff = x
-            break
-        if is_url(x):
-            ff = x
-
-    if ff is None:
-        return f"{ff} does not exist!"
-
-    ff = sys.argv[1]
-
-    return view(ff)
-
+        if os.path.exists(x) or is_url(x):
+            ff.append(x)
+        elif glob.has_magic(x):
+            # a pattern the shell did not expand (it was quoted)
+            ff += sorted(glob.glob(x))
+
+    if len(ff) == 0:
+        return f"{sys.argv[1]} does not exist!"
+
+    if len(ff) == 1:
+        view(ff[0])
+    else:
+        view(ff)
 
 
 if __name__ == '__main__':

ncplot/grid.py

@@ -0,0 +1,266 @@
+"""Grids that cannot be drawn as they are, drawn on a regular longitude-latitude
+grid instead: an unstructured grid (ICON's or FESOM's cells along one dimension,
+with a longitude and latitude each) and a curvilinear one that a quadmesh pulls
+out of shape (the seam of a global ocean grid, where the longitudes jump by 360
+degrees, and the north fold of a tripolar one, where two rows of cells are in
+the same places), as the native grids of the CMIP6 ocean models are.
+
+(Ported from oceanval's viewer_grid.py.)
+
+Each pixel of the image takes the value of the cell whose centre is nearest
+(on the sphere, so the seam and the fold do not matter), if it is near enough
+to be in that cell: within its radius, times RADIUS_FACTOR (half the diagonal
+of a square cell is 0.71 of its side). A curvilinear grid's cell's radius is
+the distance to the farthest of its neighbours along the rows and columns; an
+unstructured grid's, the distance to its fourth nearest other cell. Cells with
+no longitude or latitude, or piled up at one place (NEMO puts the cells of the
+land processors it leaves out at one point; more than the two cells of a north
+fold or a repeated column), are left out. A pixel whose cell has no value
+takes the next nearest cell it is in that has one (OWNERS are looked at), on
+a grid folded over itself only (has_folds: a ROMS grid's lines crossing),
+which can put land cells over sea cells. Which cell each pixel takes is worked out once for a grid (Raster) and
+kept (raster_for), so each map after the first costs one take. The cells'
+corners (CMIP's vertices) are not needed.
+"""
+
+import hashlib
+import warnings
+from collections import OrderedDict
+
+import numpy as np
+
+# the longest side of the image, in pixels (a quarter of a degree, round the globe)
+MAX_SIDE = 1440
+# the pixels are about this fraction of the cells' narrowest side (the median of the nearest neighbours)
+PIXEL_FACTOR = 0.5
+# a pixel is in its nearest cell if within this times the distance from that cell to its 4th nearest
+RADIUS_FACTOR = 0.75
+# how many of a cell's nearest others are looked at for its radius (piled-up cells are skipped)
+NEIGHBOURS = 8
+# a pixel's cells looked at, nearest first: the first with a value that the pixel is in gives it its value
+OWNERS = 16
+# rasters kept, for the grids drawn last
+KEPT = 4
+_kept = OrderedDict()
+
+
+def _xyz(lon, lat):
+    lon, lat = np.radians(lon), np.radians(lat)
+    return np.column_stack([np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)])
+
+
+def _wrap(lon):
+    """lon in [-180, 180)."""
+    return (np.asarray(lon, dtype="float64") + 180) % 360 - 180
+
+
+def has_seam(lon):
+    """Whether neighbouring cells of a 2-D longitude are more than 180 degrees
+    apart (the seam of a global grid, or a regional one across the dateline)."""
+    lon = _wrap(lon)
+    if lon.ndim != 2:
+        return False
+    with np.errstate(invalid="ignore"):
+        return bool(
+            (np.abs(np.diff(lon, axis=0)) > 180).any() or (np.abs(np.diff(lon, axis=1)) > 180).any()
+        )
+
+
+def has_folds(lon, lat):
+    """Whether some cells of a 2-D grid are turned over: the quadrilateral of
+    four neighbouring centres goes round the other way from most (a ROMS
+    grid's lines crossing over land), which a quadmesh draws as spikes
+    across the map."""
+    lon, lat = np.asarray(lon, dtype="float64"), np.asarray(lat, dtype="float64")
+    if lon.ndim != 2 or min(lon.shape) < 2:
+        return False
+    # longitudes as steps from a neighbour, so a seam is no fold
+    along = _wrap(lon[:-1, 1:] - lon[:-1, :-1]), lat[:-1, 1:] - lat[:-1, :-1]
+    across = _wrap(lon[1:, :-1] - lon[:-1, :-1]), lat[1:, :-1] - lat[:-1, :-1]
+    with np.errstate(invalid="ignore"):
+        turn = along[0] * across[1] - along[1] * across[0]
+        turn = turn[np.isfinite(turn) & (turn != 0)]
+    if not turn.size:
+        return False
+    return bool(min((turn > 0).sum(), (turn < 0).sum()) > 0)
+
+
+def _grid_radius(xyz):
+    """For each cell of a curvilinear grid (xyz: (ny, nx, 3), NaN where a cell
+    is left out), the farthest and the nearest of its neighbours along the
+    grid's rows and columns (chords on the unit sphere), 0 if it has none."""
+    distances = []
+    for axis in (0, 1):
+        step = np.linalg.norm(np.diff(xyz, axis=axis), axis=-1)
+        pad = [(0, 0), (0, 0)]
+        pad[axis] = (1, 0)
+        distances.append(np.pad(step, pad, constant_values=np.nan))
+        pad[axis] = (0, 1)
+        distances.append(np.pad(step, pad, constant_values=np.nan))
+    distances = np.stack(distances)
+    # a cell in the same place as its neighbour (a repeated column) is no measure of its size
+    distances[distances <= 1e-7] = np.nan
+    with np.errstate(invalid="ignore"), warnings.catch_warnings():
+        warnings.simplefilter("ignore", RuntimeWarning)
+        radius = np.nanmax(distances, axis=0)
+        nearest = np.nanmin(distances, axis=0)
+    return np.nan_to_num(radius, nan=0.0), np.nan_to_num(nearest, nan=0.0)
+
+
+def _cloud_radius(tree, points):
+    """For each of the cells at points (an unstructured grid's, (n, 3) on the
+    unit sphere, whose cKDTree is tree), the chord to its 4th nearest other
+    cell (or the farthest of those looked at), and to its nearest."""
+    k = min(NEIGHBOURS, len(points))
+    distances, _ = tree.query(points, k=k, workers=-1)
+    apart = np.where(distances > 1e-7, distances, np.nan)
+    counted = np.sum(np.isfinite(apart), axis=1)
+    apart.sort(axis=1)
+    which = np.clip(np.minimum(counted, 4) - 1, 0, None)
+    radius = np.where(counted > 0, apart[np.arange(len(apart)), which], 0.0)
+    return radius, np.where(counted > 0, apart[:, 0], 0.0)
+
+
+def _degrees(chord):
+    return np.degrees(2 * np.arcsin(np.clip(chord / 2, 0, 1)))
+
+
+class Raster:
+    """For the cells at lon, lat (arrays of one shape: a curvilinear grid's 2-D
+    ones, or an unstructured grid's 1-D ones), a regular longitude-latitude
+    grid (x_axis, y_axis: the pixels' centres) over them, at most max_side
+    pixels on its longest side, and for each pixel the cell it is in, if any."""
+
+    def __init__(self, lon, lat, max_side=MAX_SIDE):
+        from scipy.spatial import cKDTree
+
+        lon = np.asarray(lon, dtype="float64")
+        lat = np.asarray(lat, dtype="float64")
+        self.cells = lon.size
+        self.grid_shape = lon.shape
+        usable = np.isfinite(lon) & np.isfinite(lat) & (np.abs(lat) <= 90)
+        # cells piled up in one place (more than the two of a fold or a grid's repeated columns): fill values
+        rounded = np.where(usable, np.round(_wrap(lon), 5) + 1j * np.round(lat, 5), np.nan)
+        _, where, counts = np.unique(rounded.ravel(), return_inverse=True, return_counts=True)
+        piled = usable & (counts[where] > 2).reshape(lon.shape)
+        # not shown, whatever their values: a model's filler (CESM's land processors at -1, -1 have tos -1)
+        self.piled = piled.ravel()
+        usable &= ~piled
+        xyz = np.full(lon.shape + (3,), np.nan)
+        xyz[usable] = _xyz(lon[usable], lat[usable])
+        tree = None
+        if lon.ndim == 2:
+            radius, nearest = _grid_radius(xyz)
+        else:
+            radius, nearest = np.zeros(lon.shape), np.zeros(lon.shape)
+            if usable.sum() >= 2:
+                tree = cKDTree(xyz[usable])
+                radius[usable], nearest[usable] = _cloud_radius(tree, xyz[usable])
+        # the two cells in one place (across a fold) are as big as the bigger: the nearest of them is either
+        group = where.reshape(lon.shape)[usable]
+        largest = np.zeros(counts.size)
+        np.maximum.at(largest, group, radius[usable])
+        radius[usable] = largest[group]
+        keep = (usable & (radius > 0)).ravel()
+        if keep.sum() < 2:
+            raise ValueError("The grid's longitudes and latitudes place too few cells.")
+        placed = np.flatnonzero(keep)
+        points, radius = xyz.reshape(-1, 3)[keep], radius.ravel()[keep]
+        lon, lat = lon.ravel(), lat.ravel()
+        self.kept = placed
+        # the cells' size (the farthest neighbour), for the margin; their narrowest side (the nearest), for the
+        # pixels, so a cell narrow one way (near a pole) still has a pixel of its own, MAX_SIDE allowing
+        self.spacing = float(_degrees(np.median(radius)))
+        narrowest = nearest.ravel()[keep]
+        self.narrowest = float(_degrees(np.median(narrowest[narrowest > 0]))) if (narrowest > 0).any() else self.spacing
+        radius = radius * RADIUS_FACTOR
+
+        lons, lats = _wrap(lon[self.kept]), lat[self.kept]
+        # longitudes from -180 or from 0, whichever covers the cells in less (a grid across the dateline),
+        # -180 unless 0 saves more than a cell
+        shifted = lons % 360
+        if np.ptp(shifted) < np.ptp(lons) - self.spacing:
+            lons = shifted
+        pad = self.spacing / 2
+        x0, x1 = float(lons.min()) - pad, float(lons.max()) + pad
+        y0, y1 = max(float(lats.min()) - pad, -90.0), min(float(lats.max()) + pad, 90.0)
+        if x1 - x0 > 360 - self.spacing:
+            # round the globe
+            x0, x1 = (-180.0, 180.0) if lons.min() < 0 else (0.0, 360.0)
+        step = max(self.narrowest * PIXEL_FACTOR, max(x1 - x0, y1 - y0) / max_side)
+        nx, ny = max(2, int(np.ceil((x1 - x0) / step))), max(2, int(np.ceil((y1 - y0) / step)))
+        self.shape = (ny, nx)
+        self.step = step
+        self.x_axis = x0 + (np.arange(nx) + 0.5) * (x1 - x0) / nx
+        self.y_axis = y0 + (np.arange(ny) + 0.5) * (y1 - y0) / ny
+
+        if tree is None or tree.n != len(points):
+            tree = cKDTree(points)
+        px, py = np.meshgrid(self.x_axis, self.y_axis)
+        # pixels farther than any cell's radius from every cell are in none: the search stops there (without the
+        # bound, a pixel far from a dense mesh, on land, searches most of the tree)
+        # only a grid folded over itself looks past a pixel's nearest cell: elsewhere a coast's sea would spread
+        # into its land cells
+        k = min(OWNERS if has_folds(lon.reshape(self.grid_shape), lat.reshape(self.grid_shape)) else 1, len(points))
+        distance, nearest = tree.query(
+            _xyz(px.ravel(), py.ravel()), k=k, workers=-1, distance_upper_bound=float(radius.max()) * (1 + 1e-9)
+        )
+        distance, nearest = distance.reshape(-1, k), nearest.reshape(-1, k)
+        found = nearest < len(points)
+        inside = np.zeros(found.shape, dtype=bool)
+        inside[found] = distance[found] <= radius[nearest[found]]
+        self.pixels = np.flatnonzero(inside.any(axis=1))
+        # for each pixel, the cells it is in, nearest first (-1: no more); the first is its own cell
+        owners = np.where(inside, self.kept[np.where(found, nearest, 0)], -1)[self.pixels]
+        # each pixel's cells in order, those it is in first
+        order = np.argsort(owners < 0, axis=1, kind="stable")
+        owners = np.take_along_axis(owners, order, axis=1).astype("int32" if self.cells < 2**31 else "int64")
+        # no more columns than the most cells a pixel is in
+        self.candidates = owners[:, : max(1, int((owners >= 0).sum(axis=1).max()))]
+        self.owners = self.candidates[:, 0]
+
+    def image(self, values):
+        """The values of the cells (of the grid's shape, or flattened) as a
+        (ny, nx) float64 array: NaN where no cell is, or where its value is
+        missing. A pixel whose cell's value is missing takes that of the next
+        nearest cell it is in that has one (a grid folded over itself puts
+        land cells over sea cells, which they would hide)."""
+        values = np.asarray(values, dtype="float64").ravel()
+        if values.size != self.cells:
+            raise ValueError("The values are not of the grid they are drawn on.")
+        taken = values[self.owners]
+        for column in range(1, self.candidates.shape[1]):
+            missing = ~np.isfinite(taken)
+            if not missing.any():
+                break
+            cells = self.candidates[missing, column]
+            taken[missing] = np.where(cells >= 0, values[np.maximum(cells, 0)], np.nan)
+        out = np.full(self.shape[0] * self.shape[1], np.nan)
+        out[self.pixels] = taken
+        return out.reshape(self.shape)
+
+    def placed_share(self, values):
+        """The share of the cells with values that the image shows (some, at
+        least, of its pixels), cells piled up in one place left out."""
+        values = np.asarray(values, dtype="float64").ravel()
+        valued = np.isfinite(values) & ~self.piled
+        if not valued.any():
+            return 1.0
+        shown = np.zeros(values.size, dtype=bool)
+        shown[self.kept] = True
+        return float((shown & valued).sum() / valued.sum())
+
+
+def raster_for(lon, lat):
+    """The Raster of the grid at lon, lat, made the first time and kept."""
+    lon = np.ascontiguousarray(lon, dtype="float64")
+    lat = np.ascontiguousarray(lat, dtype="float64")
+    key = (lon.shape, hashlib.sha1(lon.tobytes()).hexdigest(), hashlib.sha1(lat.tobytes()).hexdigest())
+    if key in _kept:
+        _kept.move_to_end(key)
+        return _kept[key]
+    raster = Raster(lon, lat)
+    _kept[key] = raster
+    while len(_kept) > KEPT:
+        _kept.popitem(last=False)
+    return raster

ncplot/loading.py

@@ -0,0 +1,38 @@
+"""Opening a NetCDF file lazily and forgivingly."""
+
+import warnings
+
+import xarray as xr
+
+
+def decode_what_decodes(ds):
+    """``ds`` (opened with ``decode_times=False``) with each time variable that
+    can be decoded decoded, and those that cannot (FVCOM writes ``Itime2`` in
+    ``msec since 00:00:00``, which has no date) left as they were."""
+    from xarray.conventions import decode_cf_variable
+
+    decoded = {}
+    for name, variable in ds.variables.items():
+        if " since " not in str(variable.attrs.get("units", "")):
+            continue
+        try:
+            decoded[name] = decode_cf_variable(name, variable, decode_times=True)
+        except Exception:  # noqa: BLE001 - whatever xarray or cftime cannot decode stays as it is
+            continue
+    coords = {name: variable for name, variable in decoded.items() if name in ds.coords}
+    data = {name: variable for name, variable in decoded.items() if name not in ds.coords}
+    return ds.assign_coords(coords).assign(data)
+
+
+def open_one(path, **kwargs):
+    """``xr.open_dataset(path)``, falling back to decoding the times one
+    variable at a time when xarray cannot decode all of them."""
+    with warnings.catch_warnings():
+        # a reference date like FVCOM's "msec since 00:00:00" is ambiguous, and told so
+        warnings.filterwarnings("ignore", category=xr.SerializationWarning)
+        try:
+            return xr.open_dataset(path, **kwargs)
+        except ValueError as error:
+            if "decode" not in str(error).lower() and "time" not in str(error).lower():
+                raise
+        return decode_what_decodes(xr.open_dataset(path, decode_times=False, **kwargs))

ncplot/mesh.py

@@ -0,0 +1,197 @@
+"""FVCOM output: an unstructured mesh of triangles, with values on its nodes
+(node) or on its elements (nele), the triangles' nodes in nv (three, nele,
+1-based), and sigma layers (siglay, siglev) as the vertical.
+
+Which output is FVCOM's is told by the mesh's dimensions and nv.
+
+(Ported from oceanval's viewer_mesh.py.)
+
+The plotting uses pyfvcom2's approach
+(https://github.com/PlymouthMarineLaboratory/pyfvcom2, plotting/plot.py,
+FVCOMPlotter): the triangles are nv transposed, less 1 (its
+Triangulation(x, y, nv.T - 1)), on the nodes' longitudes and latitudes, and
+a field is coloured over them as its tripcolor colours it: a value on the
+nodes shaded linearly across each triangle, a value on the elements filling
+its triangle. As Bokeh cannot draw a mesh of many triangles quickly, that is
+done here onto a regular grid (Raster) and drawn as an image, pixels outside
+the mesh missing. Which triangle each pixel
+is in, and its weights, are worked out once for a mesh, so each map after
+the first costs one weighted sum. Only numpy is needed.
+"""
+
+import numpy as np
+
+# the variables that describe the mesh rather than the ocean, which are not mapped
+MESH_VARIABLES = {
+    "nv", "nbe", "nbve", "nbsn", "ntve", "ntsn", "partition", "lon", "lat", "lonc", "latc",
+    "x", "y", "xc", "yc", "siglay", "siglev", "siglay_center", "siglev_center", "Itime", "Itime2",
+    "Times", "time", "iint", "a1u", "a2u", "aw0", "awx", "awy", "art1", "art2",
+}
+
+# the longest side of a map's image, in pixels
+MAX_SIDE = 1000
+# triangle-pixel pairs looked at at once, as the raster is made
+PAIRS_AT_ONCE = 4_000_000
+
+
+def looks_like_fvcom(ds):
+    """Whether an open dataset (xarray, netCDF4 or anything with ``.dims`` or
+    ``.dimensions``, and ``.variables``) is raw FVCOM output: the unstructured
+    mesh, which output that has been regridded no longer has."""
+    dims = ds.dimensions if hasattr(ds, "dimensions") else ds.dims
+    return {"node", "nele"} <= set(dims) and "nv" in ds.variables
+
+
+def mesh_location(dims):
+    """"node" or "nele", whichever of the mesh's dimensions dims has, or None."""
+    return "node" if "node" in dims else "nele" if "nele" in dims else None
+
+
+def _array(ds, name):
+    """The variable as a float64 numpy array, NaN where it is missing."""
+    return np.asarray(ds.variables[name].values, dtype="float64")
+
+
+class Mesh:
+    """The mesh of an FVCOM file: where its nodes are (x, y: longitude and
+    latitude, or metres when the file has no longitudes), and its triangles
+    (nele, 3), 0-based."""
+
+    def __init__(self, x, y, triangles, cartesian=False):
+        self.x = np.asarray(x, dtype="float64")
+        self.y = np.asarray(y, dtype="float64")
+        self.triangles = np.asarray(triangles, dtype="int64")
+        self.cartesian = cartesian
+        self._rasters = {}
+
+    @classmethod
+    def from_dataset(cls, ds):
+        """The mesh of an open xarray Dataset of FVCOM output."""
+        if "nv" not in ds.variables:
+            raise ValueError("The dataset has no nv, so it has no FVCOM mesh.")
+        nv = np.asarray(ds.variables["nv"].values).astype("int64")
+        lon = _array(ds, "lon") if "lon" in ds.variables else None
+        lat = _array(ds, "lat") if "lat" in ds.variables else None
+        cartesian = lon is None or lat is None or not (np.nanmax(np.abs(lon)) > 0 or np.nanmax(np.abs(lat)) > 0)
+        if cartesian:
+            if "x" not in ds.variables or "y" not in ds.variables:
+                raise ValueError("The FVCOM mesh has neither longitudes and latitudes nor x and y.")
+            x, y = _array(ds, "x"), _array(ds, "y")
+        else:
+            x, y = np.where(lon > 180, lon - 360, lon), lat
+        # nv is (three, nele) and counts from 1
+        triangles = (nv.T if nv.shape[0] == 3 else nv) - 1
+        return cls(x, y, triangles, cartesian)
+
+    @classmethod
+    def read(cls, path):
+        """The mesh of the FVCOM file at path."""
+        import xarray as xr
+
+        # only the mesh is read: the file's times need not be decoded
+        with xr.open_dataset(path, decode_times=False, decode_timedelta=False) as ds:
+            return cls.from_dataset(ds[[name for name in ("nv", "lon", "lat", "x", "y") if name in ds.variables]])
+
+    @property
+    def nodes(self):
+        return len(self.x)
+
+    @property
+    def elements(self):
+        return len(self.triangles)
+
+    def raster(self, max_side=MAX_SIDE):
+        """The Raster of this mesh, at most ``max_side`` pixels on its longest
+        side (made the first time it is asked for)."""
+        if max_side not in self._rasters:
+            self._rasters[max_side] = Raster(self, max_side)
+        return self._rasters[max_side]
+
+
+class Raster:
+    """A regular grid over a mesh, at most MAX_SIDE pixels on its longest
+    side, and for each pixel inside the mesh the triangle it is in and the
+    weights of the triangle's three nodes there (barycentric coordinates)."""
+
+    def __init__(self, mesh, max_side=MAX_SIDE):
+        self.mesh = mesh
+        x, y, triangles = mesh.x, mesh.y, mesh.triangles
+        used = np.unique(triangles)
+        x0, x1 = float(np.nanmin(x[used])), float(np.nanmax(x[used]))
+        y0, y1 = float(np.nanmin(y[used])), float(np.nanmax(y[used]))
+        width, height = max(x1 - x0, 1e-12), max(y1 - y0, 1e-12)
+        if not mesh.cartesian:
+            # a degree of longitude is shorter than one of latitude
+            width *= max(np.cos(np.radians((y0 + y1) / 2)), 0.05)
+        if width >= height:
+            nx, ny = max_side, max(2, round(max_side * height / width))
+        else:
+            nx, ny = max(2, round(max_side * width / height)), max_side
+        self.shape = (ny, nx)
+        dx, dy = (x1 - x0) / nx, (y1 - y0) / ny
+        # the centres of the pixels
+        self.x_axis = x0 + (np.arange(nx) + 0.5) * dx
+        self.y_axis = y0 + (np.arange(ny) + 0.5) * dy
+
+        corners_x, corners_y = x[triangles], y[triangles]
+        # the pixels whose centres are in each triangle's bounding box
+        i_low = np.ceil((corners_x.min(axis=1) - x0) / dx - 0.5).astype("int64").clip(0, nx - 1)
+        i_high = np.floor((corners_x.max(axis=1) - x0) / dx - 0.5).astype("int64").clip(-1, nx - 1)
+        j_low = np.ceil((corners_y.min(axis=1) - y0) / dy - 0.5).astype("int64").clip(0, ny - 1)
+        j_high = np.floor((corners_y.max(axis=1) - y0) / dy - 0.5).astype("int64").clip(-1, ny - 1)
+        widths = np.maximum(i_high - i_low + 1, 0)
+        counts = widths * np.maximum(j_high - j_low + 1, 0)
+        counts[~np.isfinite(corners_x).all(axis=1) | ~np.isfinite(corners_y).all(axis=1)] = 0
+
+        pixels, owners, weights = [], [], []
+        start = 0
+        ends = np.cumsum(counts)
+        while start < len(triangles):
+            # triangles enough for PAIRS_AT_ONCE pairs (at least one)
+            done = ends[start - 1] if start else 0
+            stop = max(start + 1, int(np.searchsorted(ends, done + PAIRS_AT_ONCE, side="right")))
+            chunk = np.arange(start, min(stop, len(triangles)))
+            start = chunk[-1] + 1
+            chunk = chunk[counts[chunk] > 0]
+            if not chunk.size:
+                continue
+            owner = np.repeat(chunk, counts[chunk])
+            offsets = np.repeat(np.cumsum(counts[chunk]) - counts[chunk], counts[chunk])
+            k = np.arange(owner.size) - offsets
+            ii = i_low[owner] + k % widths[owner]
+            jj = j_low[owner] + k // widths[owner]
+            px, py = x0 + (ii + 0.5) * dx, y0 + (jj + 0.5) * dy
+            ax, ay = corners_x[owner, 0], corners_y[owner, 0]
+            bx, by = corners_x[owner, 1], corners_y[owner, 1]
+            cx, cy = corners_x[owner, 2], corners_y[owner, 2]
+            denominator = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy)
+            with np.errstate(divide="ignore", invalid="ignore"):
+                wa = ((by - cy) * (px - cx) + (cx - bx) * (py - cy)) / denominator
+                wb = ((cy - ay) * (px - cx) + (ax - cx) * (py - cy)) / denominator
+            wc = 1 - wa - wb
+            eps = -1e-9
+            inside = (denominator != 0) & (wa >= eps) & (wb >= eps) & (wc >= eps)
+            pixels.append((jj * nx + ii)[inside])
+            owners.append(owner[inside])
+            weights.append(np.stack([wa, wb, wc], axis=1)[inside].clip(0, 1))
+        pixels = np.concatenate(pixels) if pixels else np.zeros(0, "int64")
+        owners = np.concatenate(owners) if owners else np.zeros(0, "int64")
+        weights = np.concatenate(weights) if weights else np.zeros((0, 3))
+        # a pixel on an edge two triangles share goes to the first
+        pixels, first = np.unique(pixels, return_index=True)
+        self.pixels = pixels
+        self.elements = owners[first]
+        self.weights = weights[first]
+
+    def image(self, values, location="node"):
+        """The values of the mesh (one for each node, or for each element:
+        location) as a (ny, nx) float64 array: NaN outside the mesh, and
+        where any of a triangle's nodes is missing."""
+        values = np.asarray(values, dtype="float64").ravel()
+        out = np.full(self.shape[0] * self.shape[1], np.nan)
+        if location == "nele":
+            out[self.pixels] = values[self.elements]
+        else:
+            corners = values[self.mesh.triangles[self.elements]]
+            out[self.pixels] = (corners * self.weights).sum(axis=1)
+        return out.reshape(self.shape)

ncplot/plot.py

@@ -29,10 +29,44 @@ import numpy as np
 import os
 
 from ncplot.utils import get_dims, check_lon, check_lat, normalise_lon
+from ncplot.loading import open_one
+from ncplot.regrid import regrid_dataset, native_range, warn_notes
 
 hv.extension("bokeh")
 hv.Store.renderers
 
+
+def _give_frames_unique_ids():
+    """
+    Work around a holoviews bug that leaves a frame undrawn: a plot skips
+    redrawing when a new frame's ``_plot_id`` equals the last one drawn, and
+    the id defaults to ``id(element)``, a memory address. A freed element's
+    address can be reused by the next frame, so a slider step can keep the
+    frame before. Dynamic frames are given ids that are never reused instead.
+    """
+    try:
+        import itertools
+        from holoviews.plotting.plot import GenericElementPlot
+    except ImportError:
+        return
+    if getattr(GenericElementPlot._get_frame, "_ncplot_unique_ids", False):
+        return
+
+    ids = itertools.count()
+    original = GenericElementPlot._get_frame
+
+    def _get_frame(self, key):
+        frame = original(self, key)
+        if frame is not None and self.dynamic:
+            frame._plot_id = next(ids)
+        return frame
+
+    _get_frame._ncplot_unique_ids = True
+    GenericElementPlot._get_frame = _get_frame
+
+
+_give_frames_unique_ids()
+
 def as_raster():
     """
     Simple hack to rasterize when datashader is available.
@@ -400,13 +434,34 @@ def view(x, vars=None, autoscale=True, out=None, **kwargs):
                     nc_vars = ds.data_vars
                     ds = ds.to_xarray()
             except:
-                ds = xr.open_dataset(x)
+                ds = open_one(x)
         except:
             ds = xr.open_dataset(x, decode_times=False)
             warnings.warn("Warning: xarray could not decode times!")
     else:
         ds = x
 
+    # curvilinear grids (a global ocean grid's seam and north fold) and unstructured
+    # meshes (FVCOM) are put on a regular longitude-latitude grid, to be plotted as such
+    native_limits = None
+    regridded, notes = regrid_dataset(ds, vars)
+    if regridded is not None:
+        warn_notes(notes)
+        if vars is None:
+            vars = list(regridded.data_vars)
+        elif isinstance(vars, str):
+            vars = vars if vars in regridded.data_vars else list(regridded.data_vars)
+        else:
+            vars = [vv for vv in vars if vv in regridded.data_vars]
+        if len(vars) == 1 or isinstance(vars, str):
+            only = vars if isinstance(vars, str) else vars[0]
+            # the range of the values as they are: finding it from the regridded ones would read every frame
+            native_limits = native_range(ds, only)
+            if native_limits is not None and "clim" not in kwargs:
+                kwargs["clim"] = native_limits
+        ds = regridded
+        nc_vars = None
+
     if vars is None:
         if nc_vars is not None:
             vars = [x for x in nc_vars]
@@ -501,11 +556,8 @@ def view(x, vars=None, autoscale=True, out=None, **kwargs):
 
     switch_coords = False
 
-    try:
-        #import datashader
-        rasterize = True
-    except:
-        rasterize = False
+    # rasterize only if datashader is there to do it
+    rasterize = as_raster()
 
     if quadmesh:
         switch_coords = True
@@ -1104,9 +1156,13 @@ def view(x, vars=None, autoscale=True, out=None, **kwargs):
             vars = vars[0]
 
         if autoscale:
-            self_max = ds.rename({vars: "x_dim12345"}).x_dim12345.max()
-            self_min = ds.rename({vars: "x_dim12345"}).x_dim12345.min()
-            v_max = max(self_max.values, -self_min.values)
+            if native_limits is not None:
+                self_min, self_max = native_limits
+                v_max = max(self_max, -self_min)
+            else:
+                self_max = ds.rename({vars: "x_dim12345"}).x_dim12345.max()
+                self_min = ds.rename({vars: "x_dim12345"}).x_dim12345.min()
+                v_max = max(self_max.values, -self_min.values)
             if "clim" in kwargs:
                 v_max = float(max(-kwargs["clim"][0], kwargs["clim"][1]))
         else:

ncplot/regrid.py

@@ -0,0 +1,286 @@
+"""Curvilinear grids and unstructured meshes as regular longitude-latitude ones.
+
+``view`` plots regular grids well, and anything else badly: the seam of a
+global ocean grid (where the longitudes jump by 360 degrees), its tripolar
+north fold (two rows of cells in the same places), cells piled up at one
+point, and FVCOM's triangular mesh. ``regrid_dataset`` gives such variables a
+regular grid to be drawn on instead, using the engine ported from oceanval
+(``ncplot.grid`` for curvilinear and unstructured cells, ``ncplot.mesh`` for FVCOM).
+
+The result is lazy, and needs no dask: a frame (one time, one level) is read
+and put on the regular grid only when it is asked for, so a 6 GB FVCOM file
+is opened at once and each time step shown costs one slice.
+"""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+from xarray.backends import BackendArray
+from xarray.core import indexing
+
+from ncplot import grid as ncgrid
+from ncplot import mesh as ncmesh
+
+_LON_UNITS = ("degrees_east", "degree_east", "degrees_e", "degree_e", "degreee")
+_LAT_UNITS = ("degrees_north", "degree_north", "degrees_n", "degree_n", "degreen")
+
+# variables that describe a grid, not the ocean
+_BOUNDS_SUFFIXES = ("_bnds", "_bounds", "_vertices")
+
+# a grid whose longitudes and latitudes leave out more of the cells with values than this is not regridded
+MIN_PLACED = 0.9
+
+
+# ---- what a variable is on ----
+
+
+def _attr(variable, name):
+    value = variable.attrs.get(name, "")
+    return str(value) if value is not None else ""
+
+
+def _bounds_names(ds):
+    names = set()
+    for variable in ds.variables.values():
+        for key in ("bounds", "climatology", "edges"):
+            if key in variable.attrs:
+                names.add(str(variable.attrs[key]))
+    return names
+
+
+def find_lonlat(ds, name):
+    """The names of the longitude and latitude of variable ``name`` of ``ds``,
+    or Nones: its coordinates with a standard_name, units or name that says
+    so (``nav_lon`` and ``nav_lat`` too). A variable no coordinates name (an
+    unstructured grid's, whose longitudes and latitudes are variables
+    nothing points at) takes any variable on its dimensions that says it is
+    one. Attributes are read through ``ds.variables``, which is cheap."""
+    variables = ds.variables
+    variable = variables[name]
+    dims = set(variable.dims)
+    candidates = list(ds[name].coords)
+    for word in _attr(variable, "coordinates").split():
+        if word in variables and word not in candidates:
+            candidates.append(word)
+    candidates += [dim for dim in variable.dims if dim in variables and dim not in candidates]
+
+    def find(keys, standard, units, words):
+        for key in keys:
+            if _attr(variables[key], "standard_name") == standard:
+                return key
+        for key in keys:
+            if _attr(variables[key], "units").lower() in units:
+                return key
+        for key in keys:
+            if any(key.lower().startswith(word) or key.lower().endswith(word) for word in words):
+                return key
+        return None
+
+    lon = find(candidates, "longitude", _LON_UNITS, ("lon", "nav_lon", "glamt"))
+    lat = find(candidates, "latitude", _LAT_UNITS, ("lat", "nav_lat", "gphit"))
+    if lon is None or lat is None:
+        others = [key for key, other in variables.items() if key != name and other.ndim and set(other.dims) <= dims]
+        lon = lon or find(others, "longitude", _LON_UNITS, ())
+        lat = lat or find(others, "latitude", _LAT_UNITS, ())
+    # coordinates that do not span the variable's own dimensions cannot place it
+    for key in (lon, lat):
+        if key is not None and not set(variables[key].dims) <= dims:
+            return None, None
+    return lon, lat
+
+
+def _repeated_coordinates(lons, lats):
+    """Whether cells share a longitude and latitude: the 0s (or fill values)
+    a model writes at land cells, which put those cells on top of one another."""
+    pairs = pd.DataFrame({"lon": np.asarray(lons).ravel(), "lat": np.asarray(lats).ravel()})
+    return bool(pairs.duplicated().any())
+
+
+def needs_raster(lons, lats):
+    """Whether a grid at ``lons``, ``lats`` is better drawn on a regular grid
+    than as it is: an unstructured grid (1-D, cells along one dimension), or
+    a curvilinear one with a seam, cells in the same places, cells turned
+    over, or cells with no longitude or latitude."""
+    if lons.ndim == 1 and lats.ndim == 1:
+        return lons.shape == lats.shape
+    if lons.ndim != 2 or lons.shape != lats.shape:
+        return False
+    if ncgrid.has_seam(lons) or _repeated_coordinates(lons, lats) or ncgrid.has_folds(lons, lats):
+        return True
+    return bool((~np.isfinite(lons) | ~np.isfinite(lats)).any())
+
+
+class Source:
+    """What one variable is drawn from: its ``kind`` ("mesh", "cells" or
+    "grid"), its horizontal dimensions ``dims`` (in the order of its
+    longitudes and latitudes), and where its values are on an FVCOM mesh
+    (``location``: "node" or "nele")."""
+
+    def __init__(self, kind, dims, lon=None, lat=None, location=None):
+        self.kind, self.dims, self.lon, self.lat, self.location = kind, tuple(dims), lon, lat, location
+
+    @property
+    def key(self):
+        return (self.kind, self.dims, self.lon, self.lat, self.location)
+
+
+def find_source(ds, name):
+    """The Source of variable ``name`` if it needs regridding, else None."""
+    variable = ds.variables[name]
+    if variable.dtype.kind not in "fiu" or not variable.ndim:
+        return None
+    if ncmesh.looks_like_fvcom(ds):
+        location = ncmesh.mesh_location(variable.dims)
+        if name in ncmesh.MESH_VARIABLES or location is None or variable.dtype.kind != "f":
+            return None
+        return Source("mesh", [location], location=location)
+    if name.endswith(_BOUNDS_SUFFIXES):
+        return None
+    lon, lat = find_lonlat(ds, name)
+    if lon is None or lat is None:
+        return None
+    lon_dims, lat_dims = ds.variables[lon].dims, ds.variables[lat].dims
+    if len(lon_dims) == 1 and lon_dims == lat_dims and lon_dims[0] in variable.dims:
+        # cells along one dimension, each with its longitude and latitude
+        source = Source("cells", lon_dims, lon, lat)
+    elif len(lon_dims) == 2 and lon_dims == lat_dims and set(lon_dims) <= set(variable.dims):
+        source = Source("grid", lon_dims, lon, lat)
+    else:
+        return None
+    lons, lats = np.asarray(ds.variables[lon].values, dtype="float64"), np.asarray(ds.variables[lat].values, dtype="float64")
+    return source if needs_raster(lons, lats) else None
+
+
+# ---- the regular grid ----
+
+
+class RasterArray(BackendArray):
+    """A variable with its horizontal dimensions on a regular grid: the
+    ``source`` Variable's values put on ``raster`` when asked for. Its shape
+    is that of the source with its horizontal dimensions (``dims``) replaced by
+    the raster's two, last; only the frames (the other dimensions) that are
+    indexed are read."""
+
+    def __init__(self, source, dims, raster, location=None):
+        self.source, self.dims, self.raster, self.location = source, tuple(dims), raster, location
+        self.lead = [dim for dim in source.dims if dim not in self.dims]
+        self.shape = tuple(source.sizes[dim] for dim in self.lead) + tuple(raster.shape)
+        self.dtype = np.dtype("float32")
+
+    def __getitem__(self, key):
+        return indexing.explicit_indexing_adapter(key, self.shape, indexing.IndexingSupport.OUTER, self._get)
+
+    def _image(self, values):
+        if self.location is not None:
+            return self.raster.image(values, self.location)
+        return self.raster.image(values)
+
+    def _get(self, key):
+        lead_key, (key_y, key_x) = key[: len(self.lead)], key[len(self.lead):]
+        part = self.source.isel({dim: k for dim, k in zip(self.lead, lead_key)})
+        kept = [dim for dim in self.lead if dim in part.dims]
+        # the frames, each with its horizontal dimensions in the order of the grid's coordinates
+        frames = part.transpose(*kept, *self.dims).values.reshape((-1,) + tuple(part.sizes[dim] for dim in self.dims))
+        images = np.stack([self._image(np.asarray(frame, dtype="float64")) for frame in frames])
+        images = images.reshape(tuple(part.sizes[dim] for dim in kept) + tuple(self.raster.shape))
+        return images[..., key_y, :][..., key_x].astype("float32")
+
+
+def _level_coordinate(ds, dim):
+    """The coordinate of a dimension that comes through regridding: its own
+    if it has a 1-D one, else the numbers 1 to n (FVCOM's sigma layers have
+    values at each node, not one for the layer: 1 is the surface)."""
+    if dim in ds.variables and ds.variables[dim].dims == (dim,):
+        return ds.variables[dim]
+    return xr.Variable((dim,), np.arange(1, ds.sizes[dim] + 1), {"long_name": f"{dim} number"})
+
+
+def regrid_dataset(ds, names=None):
+    """``ds`` with the variables that need it (see ``needs_raster``; ``names``:
+    of these only) on a regular longitude-latitude grid, as ``(Dataset, notes)``:
+    only those variables, with dimensions ``lat`` and ``lon``, lazy. ``(None,
+    [])`` if no variable needs it, so that the dataset is plotted as it is.
+
+    A grid whose longitudes and latitudes cannot place its cells is left out
+    (it is plotted by its indices, as it was)."""
+    if names is not None:
+        names = [names] if isinstance(names, str) else list(names)
+    wanted = list(ds.data_vars) if names is None else names
+    skip = _bounds_names(ds)
+    sources = {}
+    for name in wanted:
+        if name in skip or name not in ds.variables:
+            continue
+        source = find_source(ds, name)
+        if source is not None:
+            sources[name] = source
+    if not sources:
+        return None, []
+
+    notes = []
+    rasters = {}
+    mesh = None
+    variables = {}
+    axes = None
+    for name, source in sources.items():
+        if source.key not in rasters:
+            if source.kind == "mesh":
+                if mesh is None:
+                    mesh = ncmesh.Mesh.from_dataset(ds)
+                rasters[source.key] = mesh.raster()
+            else:
+                lons = np.asarray(ds.variables[source.lon].values, dtype="float64")
+                lats = np.asarray(ds.variables[source.lat].values, dtype="float64")
+                try:
+                    raster = ncgrid.raster_for(lons, lats)
+                except ValueError:
+                    raster = None
+                if raster is not None:
+                    # a grid whose coordinates leave out many of its cells with values is plotted by its indices
+                    sample = ds[name].isel({dim: 0 for dim in ds[name].dims if dim not in source.dims})
+                    if raster.placed_share(sample.transpose(*source.dims).values) < MIN_PLACED:
+                        raster = None
+                rasters[source.key] = raster
+        raster = rasters[source.key]
+        if raster is None:
+            notes.append(f"{name}: the grid's longitudes and latitudes cannot place its cells.")
+            continue
+        if axes is not None and not (np.array_equal(axes[0], raster.x_axis) and np.array_equal(axes[1], raster.y_axis)):
+            notes.append(f"{name}: it is on another grid than the first variable, so it is left out.")
+            continue
+        axes = (raster.x_axis, raster.y_axis)
+        array = RasterArray(ds.variables[name], source.dims, raster, source.location)
+        attrs = {k: v for k, v in ds.variables[name].attrs.items() if k in ("long_name", "standard_name", "units")}
+        variables[name] = xr.Variable(array.lead + ["lat", "lon"], indexing.LazilyIndexedArray(array), attrs)
+    if not variables:
+        return None, notes
+
+    coords = {}
+    for name, variable in variables.items():
+        for dim in variable.dims[:-2]:
+            if dim not in coords:
+                coords[dim] = _level_coordinate(ds, dim)
+    coords["lat"] = xr.Variable(("lat",), axes[1], {"standard_name": "latitude", "units": "degrees_north", "axis": "Y"})
+    coords["lon"] = xr.Variable(("lon",), axes[0], {"standard_name": "longitude", "units": "degrees_east", "axis": "X"})
+    result = xr.Dataset(variables, coords=coords, attrs=dict(ds.attrs))
+    dropped = [name for name in wanted if name not in variables and name not in skip and name in ds.data_vars]
+    if names is not None and dropped:
+        notes.append("Not on a grid that is regridded, so left out: " + ", ".join(dropped))
+    return result, notes
+
+
+def native_range(ds, name):
+    """The smallest and largest value of variable ``name`` of ``ds``, from the
+    values as they are on their own grid (cheaper than on the regular one, and
+    one range for every time and level). ``(low, high)``, or None if there
+    are no values."""
+    values = ds[name]
+    low, high = float(values.min(skipna=True)), float(values.max(skipna=True))
+    return (low, high) if np.isfinite(low) and np.isfinite(high) else None
+
+
+def warn_notes(notes):
+    for note in notes:
+        warnings.warn(note)

{ncplot-0.4.2.dist-info → ncplot-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ncplot
-Version: 0.4.2
+Version: 0.4.3
 Summary: Interactive viewing of NetCDF data
 Home-page: https://github.com/pmlmodelling/ncplot
 Author: Robert Wilson
@@ -10,12 +10,12 @@ Project-URL: Bug Tracker, https://github.com/pmlmodelling/ncplot/issues
 Project-URL: Documentation, https://ncplot.readthedocs.io/en/stable
 Project-URL: Source Code, https://github.com/pmlmodelling/ncplot
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.6.1
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -28,9 +28,17 @@ Requires-Dist: panel
 Requires-Dist: pandas
 Requires-Dist: metpy
 Requires-Dist: jupyter_bokeh
+Requires-Dist: scipy
 Requires-Dist: datashader; python_version <= "3.10"
 Provides-Extra: complete
 Requires-Dist: geoviews; extra == "complete"
+Requires-Dist: cartopy; extra == "complete"
+Requires-Dist: datashader; extra == "complete"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: geoviews; extra == "test"
+Requires-Dist: cartopy; extra == "test"
+Requires-Dist: datashader; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -61,7 +69,7 @@ Dynamic: summary
 
 Easy interactive viewing of NetCDF files in Python.
 
-An easy to use Python (3.6 and above) package for quickly plotting the contents of NetCDF files or xarray datasets in Python or on the command line. 
+An easy to use Python (3.9 and above) package for quickly plotting the contents of NetCDF files or xarray datasets in Python or on the command line. 
 
 This package is designed to work with [CF](https://cfconventions.org/) compliant NetCDF data.
 
@@ -125,6 +133,24 @@ ds.ncplot.view()
 
 
 
+## Model grids
+
+Regular longitude-latitude grids are plotted as they are. Other grids are put on a regular longitude-latitude
+grid first, so that they are plotted in the same way, with the same sliders:
+
+* **Curvilinear grids** with 2-D longitudes and latitudes, such as the native ocean grids of CMIP6 models, including
+  those with a seam where the longitudes jump by 360 degrees and a tripolar north fold.
+* **Unstructured grids**, whose cells run along one dimension with a longitude and latitude each.
+* **[FVCOM](https://github.com/FVCOM-GitHub/FVCOM) output**: the triangular mesh, with variables on its nodes or its elements, and
+  sigma layers as an extra slider.
+
+Each time step and level is put on the regular grid only when it is shown. For a large file name the variable you want,
+e.g. `view("fvcom_output.nc", vars="temp")`: with several variables (the default is all of them) ncplot has to read every
+time step of each to set its colour scale.
+
+Coastlines (`view("example.nc", coast=True)`) need geoviews and cartopy, and datashader draws large regular grids
+quickly: `pip install "ncplot[complete]"`.
+
 ## How to use on the command line
 
 Command line usage is as simple as:

ncplot-0.4.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+ncplot/__init__.py,sha256=Y7JgOH_AwvTpuvmX3rnp0LBeIaEjEZkXxCEQjSpq2mc,29
+ncplot/command_line.py,sha256=uFRXzYy6Yh0-ta6E4OH8qbpnPxf7kd3erR-ZUZyo6HM,1192
+ncplot/deprecated.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ncplot/grid.py,sha256=w6P_6bc_0GPTDLZzKhAS6EDXFyvxY9q8DH3uwpR5s_k,13223
+ncplot/loading.py,sha256=aA9qH1h15Fw2ph90MTt4_iNlGz33GPm2R0Jk9R9lrAI,1668
+ncplot/mesh.py,sha256=lRaX-pL2UVjDSoMGjlf2Emx5-BTPGlWaYx_dhWequhY,9388
+ncplot/plot.py,sha256=9C39jrybAjgcu2Txgt0kCmpxASYwnUKMRsEaEZICGW4,42336
+ncplot/regrid.py,sha256=OFPZPNDxjlx1yAx1_w2OeWX98Zx4aZxC2B1cciroUFU,13006
+ncplot/utils.py,sha256=pvFahoxeuc26DtdEIp28MkyvDik8NR0aSqdHbBupQr8,6005
+ncplot/xarray.py,sha256=F-kGEufuE8ZvIdWsNpuLGjhn4Tn6aM1UNUWvHIaiOvA,535
+ncplot-0.4.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ncplot-0.4.3.dist-info/METADATA,sha256=k-Nh97nUIKg4WibB1VhmSga9BJ8cTL9-reLkiC4JXA8,5016
+ncplot-0.4.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ncplot-0.4.3.dist-info/entry_points.txt,sha256=8CIFyTPZn49GsrojImqnJpkYIbxxZHAP_rHqA-256Eo,52
+ncplot-0.4.3.dist-info/top_level.txt,sha256=hCfsI7KZNMRpk8FI5lwz_PFTyzJl91Iy2TSPAGEu9WI,7
+ncplot-0.4.3.dist-info/RECORD,,

ncplot-0.4.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-ncplot/__init__.py,sha256=Y7JgOH_AwvTpuvmX3rnp0LBeIaEjEZkXxCEQjSpq2mc,29
-ncplot/command_line.py,sha256=L4JRPyYv9clgU35H9xSmyp3A4AAiC8Zm0W1ciTYv06A,835
-ncplot/deprecated.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ncplot/plot.py,sha256=NHQzJ-jKt5nF1JDeMfZ_Jz9rt5jbuqNnH8uGteMXQvU,40052
-ncplot/utils.py,sha256=pvFahoxeuc26DtdEIp28MkyvDik8NR0aSqdHbBupQr8,6005
-ncplot/xarray.py,sha256=F-kGEufuE8ZvIdWsNpuLGjhn4Tn6aM1UNUWvHIaiOvA,535
-ncplot-0.4.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ncplot-0.4.2.dist-info/METADATA,sha256=mjSRD4vxjKR6Ch9VBVAapHaBIaozSGX1KgjbA3Bk2mY,3603
-ncplot-0.4.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-ncplot-0.4.2.dist-info/entry_points.txt,sha256=8CIFyTPZn49GsrojImqnJpkYIbxxZHAP_rHqA-256Eo,52
-ncplot-0.4.2.dist-info/top_level.txt,sha256=hCfsI7KZNMRpk8FI5lwz_PFTyzJl91Iy2TSPAGEu9WI,7
-ncplot-0.4.2.dist-info/RECORD,,