Enable upgrade rules (#153)

Author: hoxbro

pyproject.toml

@@ -93,7 +93,7 @@ select = [
     "PLR",
     "PLW",
     "RUF",
-    # "UP",
+    "UP",
     "W",
 ]
 ignore = [

spatialpandas/dask.py

@@ -271,9 +271,7 @@ def rm_retry(file_path):
                 filesystem.rm(file_path, recursive=True)
                 if filesystem.exists(file_path):
                     # Make sure we keep retrying until file does not exist
-                    raise ValueError("Deletion of {path} not yet complete".format(
-                        path=file_path
-                    ))
+                    raise ValueError(f"Deletion of {file_path} not yet complete")
 
         @retryit
         def mkdirs_retry(dir_path):
@@ -301,11 +299,9 @@ def move_retry(p1, p2):
             tempdir_format = os.path.join(path, "part.{partition}.parquet")
         elif not isinstance(tempdir_format, str) or "{partition" not in tempdir_format:
             raise ValueError(
-                "tempdir_format must be a string containing a {{partition}} "
+                "tempdir_format must be a string containing a {partition} "
                 "replacement field\n"
-                "    Received: {tempdir_format}".format(
-                    tempdir_format=repr(tempdir_format)
-                )
+                f"    Received: {tempdir_format!r}"
             )
 
         # Compute number of output partitions
@@ -419,15 +415,10 @@ def read_parquet_retry(parts_tmp_path, subpart_paths, part_output_path):
                 extras = set(ls_res) - set(subpart_paths)
                 raise ValueError(
                     "Filesystem not yet consistent\n"
-                    "  Expected len: {expected}\n"
-                    "  Found len: {received}\n"
-                    "  Missing: {missing}\n"
-                    "  Extras: {extras}".format(
-                        expected=len(subpart_paths),
-                        received=len(ls_res),
-                        missing=list(missing),
-                        extras=list(extras)
-                    )
+                    f"  Expected len: {len(subpart_paths)}\n"
+                    f"  Found len: {len(ls_res)}\n"
+                    f"  Missing: {list(missing)}\n"
+                    f"  Extras: {list(extras)}"
                 )
             return read_parquet(
                 parts_tmp_path,

spatialpandas/geometry/base.py

@@ -59,8 +59,7 @@ def _parse_subtype(cls, dtype_string):
         elif dtype_string == cls._geometry_name.lower():
             subtype_string = 'float64'
         else:
-            raise ValueError("Cannot parse {dtype_string}".format(
-                dtype_string=dtype_string))
+            raise ValueError(f"Cannot parse {dtype_string}")
 
         return subtype_string
 
@@ -73,10 +72,9 @@ def construct_from_string(cls, string):
                 raise AttributeError
         except AttributeError:
             raise TypeError(
-                "'construct_from_string' expects a string, got {typ}".format(
-                    typ=type(string)))
+                f"'construct_from_string' expects a string, got {type(string)}")
 
-        msg = "Cannot construct a '%s' from '{}'" % cls.__name__
+        msg = f"Cannot construct a '{cls.__name__}' from '{{}}'"
         if string.startswith(cls._geometry_name.lower()):
             # Extract subtype
             try:
@@ -95,7 +93,7 @@ def __init__(self, subtype):
 
         # Validate the subtype is numeric
         if self.subtype.kind not in ('i', 'u', 'f'):
-            raise ValueError("Received non-numeric type of kind '{}'".format(self.kind))
+            raise ValueError(f"Received non-numeric type of kind '{self.kind}'")
 
         array_type = self.construct_array_type()
         self.arrow_dtype = array_type._arrow_type_from_numpy_element_dtype(subtype)
@@ -104,10 +102,10 @@ def __hash__(self):
         return hash((self.__class__, self.arrow_dtype))
 
     def __str__(self):
-        return "{}[{}]".format(self._geometry_name, str(self.subtype.name))
+        return f"{self._geometry_name}[{self.subtype.name!s}]"
 
     def __repr__(self):
-        return "{}({})".format(self.__class__.__name__,  str(self.subtype.name))
+        return f"{self.__class__.__name__}({self.subtype.name!s})"
 
     @property
     def type(self):
@@ -137,7 +135,7 @@ def __init__(self, data, dtype=None):
             self.data = pa.array([data])[0]
 
     def __repr__(self):
-        return "{}({})".format(self.__class__.__name__, self.data.as_py())
+        return f"{self.__class__.__name__}({self.data.as_py()})"
 
     def __hash__(self):
         return hash((self.__class__, np.array(self.data.as_py()).tobytes()))
@@ -172,7 +170,7 @@ def intersects_bounds(self, bounds):
 
     def intersects(self, shape):
         raise NotImplementedError(
-            "intersects not yet implemented for %s objects" % type(self).__name__
+            f"intersects not yet implemented for {type(self).__name__} objects"
         )
 
 
@@ -247,9 +245,7 @@ def __init__(self, array, dtype=None, copy=None):
             array = pa.concat_arrays(array.chunks)
         else:
             raise ValueError(
-                "Unsupported type passed for {}: {}".format(
-                    self.__class__.__name__, type(array)
-                )
+                f"Unsupported type passed for {self.__class__.__name__}: {type(array)}"
             )
 
         # Save off pyarrow array
@@ -326,13 +322,10 @@ def copy(self):
     def __eq__(self, other):
         if type(other) is type(self):
             if len(other) != len(self):
-                raise ValueError("""
-Cannot check equality of {typ} instances of unequal length
-    len(ra1) == {len_a1}
-    len(ra2) == {len_a2}""".format(
-                    typ=type(self).__name__,
-                    len_a1=len(self),
-                    len_a2=len(other)))
+                raise ValueError(f"""
+Cannot check equality of {type(self).__name__} instances of unequal length
+    len(ra1) == {len(self)}
+    len(ra2) == {len(other)}""")
             result = np.zeros(len(self), dtype=np.bool_)
             for i in range(len(self)):
                 result[i] = self[i] == other[i]
@@ -342,9 +335,9 @@ def __eq__(self, other):
             for i in range(len(self)):
                 result[i] = self[i] == other
             return result
-        raise ValueError("""
-Cannot check equality of {typ} of length {a_len} with:
-    {other}""".format(typ=type(self).__name__, a_len=len(self), other=repr(other)))
+        raise ValueError(f"""
+Cannot check equality of {type(self).__name__} of length {len(self)} with:
+    {other!r}""")
 
     def __contains__(self, item) -> bool:
         raise NotImplementedError
@@ -364,7 +357,7 @@ def __getitem__(self, item):
         if isinstance(item, Integral):
             item = int(item)
             if item < -len(self) or item >= len(self):
-                raise IndexError("{item} is out of bounds".format(item=item))
+                raise IndexError(f"{item} is out of bounds")
             else:
                 # Convert negative item index
                 if item < 0:
@@ -396,8 +389,8 @@ def __getitem__(self, item):
                 # Check mask length is compatible
                 if len(item) != len(self):
                     raise IndexError(
-                        "Boolean index has wrong length: {} instead of {}"
-                        .format(len(item), len(self))
+                        f"Boolean index has wrong length: {len(item)} instead of {len(self)}"
+
                     )
 
                 # check for NA values
@@ -429,9 +422,7 @@ def take(self, indices, allow_fill=False, fill_value=None):
         # Validate self non-empty (Pandas expects this error when array is empty)
         if (len(self) == 0 and len(indices) > 0 and
                 (not allow_fill or any(indices >= 0))):
-            raise IndexError("cannot do a non-empty take from an empty axes|out of bounds on {typ}".format(
-                typ=self.__class__.__name__,
-            ))
+            raise IndexError(f"cannot do a non-empty take from an empty axes|out of bounds on {self.__class__.__name__}")
 
         # Validate fill values
         if allow_fill and not (
@@ -447,24 +438,17 @@ def take(self, indices, allow_fill=False, fill_value=None):
 
         if any(invalid_mask):
             raise IndexError(
-                "Index value out of bounds for {typ} of length {n}: "
-                "{idx}".format(
-                    typ=self.__class__.__name__,
-                    n=len(self),
-                    idx=indices[invalid_mask][0]
-                )
+                f"Index value out of bounds for {self.__class__.__name__} of length {len(self)}: "
+                f"{indices[invalid_mask][0]}"
             )
 
         if allow_fill:
             invalid_mask = indices < -1
             if any(invalid_mask):
                 # ValueError expected by pandas ExtensionArray test suite
                 raise ValueError(
-                    "Invalid index value for {typ} with allow_fill=True: "
-                    "{idx}".format(
-                        typ=self.__class__.__name__,
-                        idx=indices[invalid_mask][0]
-                    )
+                    f"Invalid index value for {self.__class__.__name__} with allow_fill=True: "
+                    f"{indices[invalid_mask][0]}"
                 )
 
             # Build pyarrow array of indices
@@ -523,8 +507,8 @@ def fillna(self, value=None, method=None, limit=None):
         if is_array_like(value):
             if len(value) != len(self):
                 raise ValueError(
-                    "Length of 'value' does not match. Got ({}) "
-                    " expected {}".format(len(value), len(self))
+                    f"Length of 'value' does not match. Got ({len(value)}) "
+                    f" expected {len(self)}"
                 )
             value = value[mask]
 
@@ -636,7 +620,7 @@ def intersects(self, shape, inds=None):
             with the supplied shape
         """
         raise NotImplementedError(
-            "intersects not yet implemented for %s objects" % type(self).__name__
+            f"intersects not yet implemented for {type(self).__name__} objects"
         )
 
     def _pad_or_backfill(self, method, **kwargs):

spatialpandas/geometry/basefixed.py

@@ -35,7 +35,7 @@ def __len__(self):
         return 8 * len(self.data.as_py()) // self.pyarrow_type.bit_width
 
     def __repr__(self):
-        return "{}({})".format(self.__class__.__name__, self.flat_values.tolist())
+        return f"{self.__class__.__name__}({self.flat_values.tolist()})"
 
     @property
     def flat_values(self):
@@ -71,15 +71,13 @@ def __init__(self, array, dtype=None):
 
         def invalid_array():
             err_msg = (
-                "Invalid array with type {typ}\n"
-                "A {cls} may be constructed from:\n"
-                "    - A 1-d array with length divisible by {n} of interleaved\n"
+                f"Invalid array with type {type(array)}\n"
+                f"A {self.__class__.__name__} may be constructed from:\n"
+                f"    - A 1-d array with length divisible by {self._element_len} of interleaved\n"
                 "      x y coordinates\n"
-                "    - A tuple of {n} 1-d arrays\n"
+                f"    - A tuple of {self._element_len} 1-d arrays\n"
                 "    - A pyarrow.FixedSizeBinaryArray. In this case the dtype\n"
                 "      argument must also be specified"
-            ).format(
-                typ=type(array), cls=self.__class__.__name__, n=self._element_len,
             )
             raise ValueError(err_msg)
 

spatialpandas/geometry/baselist.py

@@ -20,17 +20,14 @@ def _validate_nested_arrow_type(nesting_levels, pyarrow_type):
     for i in range(nesting_levels):
         if not isinstance(pyarrow_element_type, pa.ListType):
             raise ValueError(
-                "Expected input data to have {} nested layer(s)".format(
-                    nesting_levels)
+                f"Expected input data to have {nesting_levels} nested layer(s)"
             )
         pyarrow_element_type = pyarrow_element_type.value_type
     numpy_element_dtype = pyarrow_element_type.to_pandas_dtype()
     if (numpy_element_dtype() is None
             or numpy_element_dtype().dtype.kind not in ('i', 'u', 'f')):
         raise ValueError(
-            "Invalid nested element type {}, expected numeric type".format(
-                pyarrow_element_type
-            ))
+            f"Invalid nested element type {pyarrow_element_type}, expected numeric type")
     return pyarrow_element_type
 
 

spatialpandas/geometry/line.py

@@ -31,9 +31,9 @@ def _shapely_to_coordinates(cls, shape):
             # Single line
             return np.asarray(shape.coords).ravel()
         else:
-            raise ValueError("""
-Received invalid value of type {typ}. Must be an instance of LineString
-or LinearRing""".format(typ=type(shape).__name__))
+            raise ValueError(f"""
+Received invalid value of type {type(shape).__name__}. Must be an instance of LineString
+or LinearRing""")
 
     def to_shapely(self):
         """

spatialpandas/geometry/multiline.py

@@ -41,9 +41,9 @@ def _shapely_to_coordinates(cls, shape):
         elif isinstance(shape, (sg.LineString, sg.LinearRing)):
             return [np.asarray(shape.coords).ravel()]
         else:
-            raise ValueError("""
-Received invalid value of type {typ}. Must be an instance of MultiLineString
-""".format(typ=type(shape).__name__))
+            raise ValueError(f"""
+Received invalid value of type {type(shape).__name__}. Must be an instance of MultiLineString
+""")
 
     def to_shapely(self):
         """

spatialpandas/geometry/multipoint.py

@@ -32,9 +32,9 @@ def _shapely_to_coordinates(cls, shape):
         elif isinstance(shape, sg.MultiPoint):
             return np.hstack([g.coords for g in shape.geoms]).ravel()
         else:
-            raise ValueError("""
-Received invalid value of type {typ}. Must be an instance of Point,
-or MultiPoint""".format(typ=type(shape).__name__))
+            raise ValueError(f"""
+Received invalid value of type {type(shape).__name__}. Must be an instance of Point,
+or MultiPoint""")
 
     def to_shapely(self):
         """

spatialpandas/geometry/multipolygon.py

@@ -49,9 +49,9 @@ def _shapely_to_coordinates(cls, shape):
         elif isinstance(shape, sg.Polygon):
             return [Polygon._shapely_to_coordinates(shape)]
         else:
-            raise ValueError("""
-Received invalid value of type {typ}. Must be an instance of Polygon or MultiPolygon
-""".format(typ=type(shape).__name__))
+            raise ValueError(f"""
+Received invalid value of type {type(shape).__name__}. Must be an instance of Polygon or MultiPolygon
+""")
 
     def to_shapely(self):
         """

spatialpandas/geometry/point.py

@@ -29,9 +29,9 @@ def _shapely_to_coordinates(cls, shape):
             # Single point
             return np.asarray(shape.coords).ravel()
         else:
-            raise ValueError("""
-Received invalid value of type {typ}. Must be an instance of Point,
-or MultiPoint""".format(typ=type(shape).__name__))
+            raise ValueError(f"""
+Received invalid value of type {type(shape).__name__}. Must be an instance of Point,
+or MultiPoint""")
 
     def to_shapely(self):
         """
@@ -146,7 +146,7 @@ def intersects(self, shape):
         elif isinstance(shape, MultiPolygon):
             return self._intersects_polygon(shape)
         else:
-            raise ValueError("Unsupported intersection type %s" % type(shape).__name__)
+            raise ValueError(f"Unsupported intersection type {type(shape).__name__}")
 
 
 class PointArray(GeometryFixedArray):
@@ -252,7 +252,7 @@ def intersects(self, shape, inds=None):
         elif isinstance(shape, MultiPolygon):
             return self._intersects_polygon(shape, inds)
         else:
-            raise ValueError("Unsupported intersection type %s" % type(shape).__name__)
+            raise ValueError(f"Unsupported intersection type {type(shape).__name__}")
 
 
 @ngpjit