Drop support for 3.7

Author: sjsrey

.github/workflows/unittests.yml

@@ -20,7 +20,6 @@
        matrix:
          os: ['ubuntu-latest']
          environment-file: [
-            ci/38-minimal.yaml,
             ci/38.yaml,
             ci/39.yaml,
             ci/310.yaml,

ci/38-minimal.yaml

@@ -2,6 +2,7 @@
 import tempfile
 
 import unittest
+import pytest
 from ..weights import W, WSP
 from .. import util
 from ..util import WSP2W, lat2W
@@ -373,6 +374,10 @@ def test_to_sparse(self):
         sparse = self.w_islands.to_sparse()
         self.assertIsInstance(sparse, scipy.sparse._arrays.coo_array)
 
+    def test_sparse_fmt(self):
+        with pytest.raises(ValueError) as exc_info:
+            sparse = self.w_islands.to_sparse("dog")
+
     def test_from_sparse(self):
         sparse = self.w_islands.to_sparse()
         w = W.from_sparse(sparse)
@@ -714,6 +719,11 @@ def test_trcWtW_WW(self):
     def test_s0(self):
         self.assertEqual(self.w3x3.s0, 24.0)
 
+    def test_from_WSP(self):
+        w = W.from_WSP(self.wsp)
+        self.assertEqual(w.n, 100)
+        self.assertEqual(w.pct_nonzero, 4.62)
+
 
 if __name__ == "__main__":
     unittest.main()

libpysal/weights/tests/test_weights.py

@@ -24,6 +24,7 @@
 
 try:
     from shapely.geometry.base import BaseGeometry
+
     HAS_SHAPELY = True
 except ImportError:
     HAS_SHAPELY = False
@@ -534,17 +535,17 @@ def higher_order_sp(
         )
 
     if lower_order:
-        wk = sum(map(lambda x: w ** x, range(2, k + 1)))
+        wk = sum(map(lambda x: w**x, range(2, k + 1)))
         shortest_path = False
     else:
-        wk = w ** k
+        wk = w**k
 
     rk, ck = wk.nonzero()
     sk = set(zip(rk, ck))
 
     if shortest_path:
         for j in range(1, k):
-            wj = w ** j
+            wj = w**j
             rj, cj = wj.nonzero()
             sj = set(zip(rj, cj))
             sk.difference_update(sj)
@@ -826,14 +827,12 @@ def WSP2W(wsp, **kwargs):
 
 
     """
-    wsp.sparse
-    indices = wsp.sparse.indices
     data = wsp.sparse.data
     indptr = wsp.sparse.indptr
     id_order = wsp.id_order
     if id_order:
         # replace indices with user IDs
-        indices = [id_order[i] for i in indices]
+        indices = [id_order[i] for i in wsp.sparse.indices]
     else:
         id_order = list(range(wsp.n))
     neighbors, weights = {}, {}
@@ -1086,12 +1085,7 @@ def get_points_array(iterable):
                 ]
             )
         else:
-            data = np.vstack(
-                [
-                    np.array(shape.centroid)
-                    for shape in first_choice
-                ]
-            )
+            data = np.vstack([np.array(shape.centroid) for shape in first_choice])
     except AttributeError:
         data = np.vstack([shape for shape in backup])
     return data

libpysal/weights/util.py

@@ -234,7 +234,67 @@ def from_shapefile(cls, *args, **kwargs):
 
     @classmethod
     def from_WSP(cls, WSP, silence_warnings=True):
-        return WSP2W(WSP, silence_warnings=silence_warnings)
+        """Create a pysal W from a pysal WSP object (thin weights matrix).
+
+        Parameters
+        ----------
+        wsp                     : WSP
+                                PySAL sparse weights object
+
+        silence_warnings        : bool
+           By default ``libpysal`` will print a warning if the dataset contains
+           any disconnected components or islands. To silence this warning set this
+           parameter to ``True``.
+
+
+        Returns
+        -------
+        w       : W
+                PySAL weights object
+
+        Examples
+        --------
+        >>> from libpysal.weights import lat2W, WSP, W
+
+        Build a 10x10 scipy.sparse matrix for a rectangular 2x5 region of cells
+        (rook contiguity), then construct a PySAL sparse weights object (wsp).
+
+        >>> sp = lat2SW(2, 5)
+        >>> wsp = WSP(sp)
+        >>> wsp.n
+        10
+        >>> wsp.sparse[0].todense()
+        matrix([[0, 1, 0, 0, 0, 1, 0, 0, 0, 0]], dtype=int8)
+
+        Create a standard PySAL W from this sparse weights object.
+
+        >>> w = W.from_WSP(wsp)
+        >>> w.n
+        10
+        >>> print(w.full()[0][0])
+        [0 1 0 0 0 1 0 0 0 0]
+        """
+        data = WSP.sparse.data
+        indptr = WSP.sparse.indptr
+        id_order = WSP.id_order
+        if id_order:
+            # replace indices with user IDs
+            indices = [id_order[i] for i in WSP.sparse.indices]
+        else:
+            id_order = list(range(WSP.n))
+        neighbors, weights = {}, {}
+        start = indptr[0]
+        for i in range(WSP.n):
+            oid = id_order[i]
+            end = indptr[i + 1]
+            neighbors[oid] = indices[start:end]
+            weights[oid] = data[start:end]
+            start = end
+        ids = copy.copy(WSP.id_order)
+        w = W(neighbors, weights, ids, silence_warnings=silence_warnings)
+        w._sparse = copy.deepcopy(WSP.sparse)
+        w._cache["sparse"] = w._sparse
+        return w
 
     @classmethod
     def from_adjlist(
@@ -452,7 +512,7 @@ def to_sparse(self, fmt="coo"):
             n = self.n
             return disp[fmt_l]((data, (row, col)), shape=(n, n))
         else:
-            warnings.warn(f"{fmt} not supported.")
+            raise ValueError(f"unsupported sparse format: {fmt}")
 
     @property
     def n_components(self):