Remove esri.py and datashader from core dependencies (#953)

* Remove esri.py and datashader from core dependencies (#947)

Delete esri.py (unused REST client for ArcGIS feature services).

Move datashader from install_requires to extras_require[examples].
Replace ds.Canvas coordinate hacks in terrain.py and datasets/__init__.py
with np.linspace. Replace tf.Image with PIL.Image in bands_to_img and
color_values. Add local hex-to-RGB helper to replace datashader.colors.rgb.
Make canvas_like lazy-import datashader with a clear ImportError.
Update test_viewshed.py fixture to build coords without datashader.

* Make PIL import lazy in bands_to_img and color_values (#947)

Pillow is not a declared dependency, so importing it at module level
breaks environments that don't have it installed (like CI).
Move the import inside the two functions that need it.

* Skip test_canvas_like when datashader is not installed (#947)

* Remove test_canvas_like (#947)

Author: brendancol

setup.cfg

@@ -19,7 +19,6 @@ url = https://github.com/xarray-contrib/xarray-spatial
 [options]
 include_package_data = True
 install_requires =
-    datashader >= 0.15.0
     numba
     scipy
     xarray
@@ -48,6 +47,7 @@ doc =
     sphinx-panels
     sphinx_rtd_theme
 examples =
+    datashader >= 0.15.0
 optional =
     # Optional for polygonize return types.
     awkward>=1.4

xrspatial/datasets/__init__.py

@@ -5,9 +5,7 @@
 except ImportError:
     da = None
 
-import datashader as ds
 import numpy as np
-import pandas as pd
 import xarray as xr
 
 __all__ = [
@@ -113,20 +111,19 @@ def _func(arr, block_id=None):
         .map_blocks(_func, dtype=np.float32)
     )
 
-    cvs = ds.Canvas(
-        x_range=(0, 500),
-        y_range=(0, 500),
-        plot_width=shape[1],
-        plot_height=shape[0],
-    )
-
-    hack_agg = cvs.points(pd.DataFrame({'x': [], 'y': []}), 'x', 'y')
+    # Build pixel-center coordinates
+    x_range = (0, 500)
+    y_range = (0, 500)
+    dx = (x_range[1] - x_range[0]) / shape[1]
+    dy = (y_range[1] - y_range[0]) / shape[0]
+    xs = np.linspace(x_range[0] + dx / 2, x_range[1] - dx / 2, shape[1])
+    ys = np.linspace(y_range[0] + dy / 2, y_range[1] - dy / 2, shape[0])
 
     agg = xr.DataArray(
         data,
         name='terrain',
-        coords=hack_agg.coords,
-        dims=hack_agg.dims,
+        coords={'y': ys, 'x': xs},
+        dims=['y', 'x'],
         attrs={'res': 1},
     )
 

xrspatial/esri.py

@@ -4,10 +4,8 @@
 from functools import partial
 from typing import Dict, List, Optional, Tuple, Union
 
-import datashader as ds
 # 3rd-party
 import numpy as np
-import pandas as pd
 import xarray as xr
 
 try:
@@ -633,18 +631,16 @@ def generate_terrain(agg: xr.DataArray,
                       octaves, lacunarity, persistence, noise_mode,
                       warp_strength, warp_octaves, worley_blend, worley_seed)
 
-    canvas = ds.Canvas(
-        plot_width=width, plot_height=height, x_range=x_range, y_range=y_range
-    )
-
-    # DataArray coords were coming back different from cvs.points...
-    hack_agg = canvas.points(pd.DataFrame({'x': [], 'y': []}), 'x', 'y')
-    res = get_dataarray_resolution(hack_agg)
+    # Build pixel-center coordinates (matches datashader Canvas convention)
+    dx = (x_range[1] - x_range[0]) / width
+    dy = (y_range[1] - y_range[0]) / height
+    xs = np.linspace(x_range[0] + dx / 2, x_range[1] - dx / 2, width)
+    ys = np.linspace(y_range[0] + dy / 2, y_range[1] - dy / 2, height)
     result = xr.DataArray(out,
                           name=name,
-                          coords=hack_agg.coords,
-                          dims=hack_agg.dims,
-                          attrs={'res': res})
+                          coords={'y': ys, 'x': xs},
+                          dims=['y', 'x'],
+                          attrs={'res': (dx, dy)})
 
     # --- hydraulic erosion ---
     if erode:

xrspatial/terrain.py

@@ -4,18 +4,7 @@
 import warnings
 
 
-from xrspatial.datasets import make_terrain
 from xrspatial import utils
-from xrspatial.tests.general_checks import dask_array_available
-
-
-@dask_array_available
-def test_canvas_like():
-    # aspect ratio is 1:1
-    terrain_shape = (1000, 1000)
-    terrain = make_terrain(shape=terrain_shape)
-    terrain_res = utils.canvas_like(terrain, width=50)
-    assert terrain_res.shape == (50, 50)
 
 
 def test_warn_if_unit_mismatch_degrees_horizontal_elevation_vertical(monkeypatch):

xrspatial/tests/test_utils.py

@@ -1,7 +1,5 @@
 import dask.array as da
-import datashader as ds
 import numpy as np
-import pandas as pd
 import pytest
 import xarray as xa
 
@@ -14,19 +12,23 @@
 
 @pytest.fixture
 def empty_agg():
-    # create an empty image of size 5*5
+    # create an empty DataArray of size 5x5 with coordinates
     H = 5
     W = 5
-
-    canvas = ds.Canvas(plot_width=W, plot_height=H,
-                       x_range=(-20, 20), y_range=(-20, 20))
-
-    empty_df = pd.DataFrame({
-       'x': np.random.normal(.5, 1, 0),
-       'y': np.random.normal(.5, 1, 0)
-    })
-    agg = canvas.points(empty_df, 'x', 'y')
-    return agg.astype('i8')
+    x_range = (-20, 20)
+    y_range = (-20, 20)
+
+    dx = (x_range[1] - x_range[0]) / W
+    dy = (y_range[1] - y_range[0]) / H
+    xs = np.linspace(x_range[0] + dx / 2, x_range[1] - dx / 2, W)
+    ys = np.linspace(y_range[0] + dy / 2, y_range[1] - dy / 2, H)
+
+    agg = xa.DataArray(
+        np.zeros((H, W), dtype='i8'),
+        coords={'y': ys, 'x': xs},
+        dims=['y', 'x'],
+    )
+    return agg
 
 
 def test_viewshed_invalid_x_view(empty_agg):

xrspatial/tests/test_viewshed.py

@@ -3,11 +3,8 @@
 from math import ceil
 import warnings
 
-import datashader as ds
-import datashader.transfer_functions as tf
 import numpy as np
 import xarray as xr
-from datashader.colors import rgb
 from numba import cuda, jit
 
 try:
@@ -558,14 +555,16 @@ def height_implied_by_aspect_ratio(W, X, Y):
 
 
 def bands_to_img(r, g, b, nodata=1):
+    from PIL import Image
+
     h, w = r.shape
     data = np.zeros((h, w, 4), dtype=np.uint8)
     data[:, :, 0] = (r).astype(np.uint8)
     data[:, :, 1] = (g).astype(np.uint8)
     data[:, :, 2] = (b).astype(np.uint8)
     a = np.where(np.logical_or(np.isnan(r), r <= nodata), 0, 255)
     data[:, :, 3] = a.astype(np.uint8)
-    return tf.Image.fromarray(data, "RGBA")
+    return Image.fromarray(data, "RGBA")
 
 
 def canvas_like(
@@ -631,6 +630,13 @@ def canvas_like(
         # set width and height
         height = height_implied_by_aspect_ratio(width, x_range, y_range)
 
+    try:
+        import datashader as ds
+    except ImportError:
+        raise ImportError(
+            "canvas_like requires datashader: pip install datashader"
+        )
+
     cvs = ds.Canvas(
         plot_width=width, plot_height=height, x_range=x_range, y_range=y_range
     )
@@ -639,14 +645,23 @@ def canvas_like(
     return out
 
 
+def _hex_to_rgb(c):
+    """Convert a hex color string (e.g. '#ff0000' or 'ff0000') to (r, g, b)."""
+    c = c.lstrip('#')
+    return int(c[0:2], 16), int(c[2:4], 16), int(c[4:6], 16)
+
+
 def color_values(agg, color_key, alpha=255):
+    from PIL import Image
+
     def _convert_color(c):
-        r, g, b = rgb(c)
+        r, g, b = _hex_to_rgb(c)
         return np.array([r, g, b, alpha]).astype(np.uint8).view(np.uint32)[0]
 
     _converted_colors = {k: _convert_color(v) for k, v in color_key.items()}
     f = np.vectorize(lambda v: _converted_colors.get(v, 0))
-    return tf.Image(f(agg.data))
+    return Image.fromarray(f(agg.data).astype(np.uint32).view(np.uint8).reshape(
+        agg.data.shape + (4,)), "RGBA")
 
 
 def _infer_coord_unit_type(coord: xr.DataArray, cellsize: float) -> str:

xrspatial/utils.py

@@ -1502,7 +1502,7 @@ def suggest_zonal_canvas(
     --------
     .. sourcecode:: python
 
-        >>> # Imports
+        >>> # Imports (datashader is optional: pip install datashader)
         >>> from spatialpandas import GeoDataFrame
         >>> import geopandas as gpd
         >>> import datashader as ds