Clean up the remaining auto-fixes for the tcod package and scripts.

Author: HexDecimal

scripts/generate_charmap_table.py

@@ -13,6 +13,8 @@
 
 import tcod.tileset
 
+# ruff: noqa: INP001
+
 
 def get_charmaps() -> Iterator[str]:
     """Return an iterator of the current character maps from tcod.tilest."""
@@ -53,6 +55,7 @@ def generate_table(charmap: Iterable[int]) -> str:
 
 
 def main() -> None:
+    """Main entry point."""
     parser = argparse.ArgumentParser(
         description="Generate an RST table for a tcod character map.",
     )

scripts/get_release_description.py

@@ -5,6 +5,8 @@
 import re
 from pathlib import Path
 
+# ruff: noqa: INP001
+
 TAG_BANNER = r"## \[[\w.]*\] - \d+-\d+-\d+\n"
 
 RE_BODY = re.compile(rf".*?{TAG_BANNER}(.*?){TAG_BANNER}", re.DOTALL)

tcod/_internal.py

@@ -168,7 +168,7 @@ def __exit__(
 class _CDataWrapper:
     """A generally deprecated CData wrapper class used by libtcodpy."""
 
-    def __init__(self, *args: Any, **kwargs: Any):  # noqa: ANN401
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
         self.cdata = self._get_cdata_from_args(*args, **kwargs)
         if self.cdata is None:
             self.cdata = ffi.NULL

tcod/console.py

@@ -1,5 +1,4 @@
-"""
-Libtcod consoles are a strictly tile-based representation of text and color.
+"""Libtcod consoles are a strictly tile-based representation of text and color.
 To render a console you need a tileset and a window to render to.
 See :ref:`getting-started` for info on how to set those up.
 """
@@ -117,7 +116,7 @@ def __init__(
         height: int,
         order: Literal["C", "F"] = "C",
         buffer: NDArray[Any] | None = None,
-    ):
+    ) -> None:
         self._key_color: tuple[int, int, int] | None = None
         self._order = tcod._internal.verify_order(order)
         if buffer is not None:

tcod/loader.py

@@ -5,7 +5,7 @@
 import platform
 import sys
 from pathlib import Path
-from typing import Any  # noqa: F401
+from typing import Any
 
 import cffi
 
@@ -54,7 +54,7 @@ def get_sdl_version() -> str:
     os.environ["PATH"] = f"""{Path(__file__).parent / get_architecture()}{os.pathsep}{os.environ["PATH"]}"""
 
 
-class _Mock(object):
+class _Mock:
     """Mock object needed for ReadTheDocs."""
 
     @staticmethod
@@ -64,7 +64,6 @@ def def_extern() -> Any:
 
     def __getattr__(self, attr: str) -> None:
         """Return None on any attribute."""
-        return None
 
     def __bool__(self) -> bool:
         """Allow checking for this mock object at import time."""
@@ -80,7 +79,7 @@ def __bool__(self) -> bool:
     lib = ffi = _Mock()
 else:
     verify_dependencies()
-    from tcod._libtcod import ffi, lib  # type: ignore # noqa: F401
+    from tcod._libtcod import ffi, lib  # type: ignore
 
     __sdl_version__ = get_sdl_version()
 

tcod/los.py

@@ -1,15 +1,15 @@
 """This modules holds functions for NumPy-based line of sight algorithms."""
 from __future__ import annotations
 
-from typing import Any, Tuple
+from typing import Any
 
 import numpy as np
 from numpy.typing import NDArray
 
 from tcod.loader import ffi, lib
 
 
-def bresenham(start: Tuple[int, int], end: Tuple[int, int]) -> NDArray[np.intc]:
+def bresenham(start: tuple[int, int], end: tuple[int, int]) -> NDArray[np.intc]:
     """Return a thin Bresenham line as a NumPy array of shape (length, 2).
 
     `start` and `end` are the endpoints of the line.

tcod/map.py

@@ -1,11 +1,8 @@
-"""libtcod map attributes and field-of-view functions.
-
-
-"""
+"""libtcod map attributes and field-of-view functions."""
 from __future__ import annotations
 
 import warnings
-from typing import Any, Tuple
+from typing import Any
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -16,7 +13,7 @@
 from tcod.loader import ffi, lib
 
 
-class Map(object):
+class Map:
     """A map containing libtcod attributes.
 
     .. versionchanged:: 4.1
@@ -77,7 +74,7 @@ def __init__(
         width: int,
         height: int,
         order: Literal["C", "F"] = "C",
-    ):
+    ) -> None:
         warnings.warn(
             "This class may perform poorly and is no longer needed.",
             DeprecationWarning,
@@ -140,15 +137,15 @@ def compute_fov(
         """
         if not (0 <= x < self.width and 0 <= y < self.height):
             warnings.warn(
-                "Index (%r, %r) is outside of this maps shape (%r, %r)."
-                "\nThis will raise an error in future versions." % (x, y, self.width, self.height),
+                "Index ({}, {}) is outside of this maps shape ({}, {})."
+                "\nThis will raise an error in future versions.".format(x, y, self.width, self.height),
                 RuntimeWarning,
                 stacklevel=2,
             )
 
         lib.TCOD_map_compute_fov(self.map_c, x, y, radius, light_walls, algorithm)
 
-    def __setstate__(self, state: Any) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         if "_Map__buffer" not in state:  # deprecated
             # remove this check on major version update
             self.__buffer = np.zeros((state["height"], state["width"], 3), dtype=np.bool_)
@@ -157,20 +154,18 @@ def __setstate__(self, state: Any) -> None:
             self.__buffer[:, :, 2] = state["buffer"] & 0x04
             del state["buffer"]
             state["_order"] = "F"
-        if "_order" not in state:  # remove this check on major version update
-            raise RuntimeError("This Map was saved with a bad version of tdl.")
         self.__dict__.update(state)
         self.map_c = self.__as_cdata()
 
-    def __getstate__(self) -> Any:
+    def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
         del state["map_c"]
         return state
 
 
 def compute_fov(
     transparency: ArrayLike,
-    pov: Tuple[int, int],
+    pov: tuple[int, int],
     radius: int = 0,
     light_walls: bool = True,
     algorithm: int = tcod.constants.FOV_RESTRICTIVE,
@@ -240,14 +235,12 @@ def compute_fov(
     if len(transparency.shape) != 2:
         raise TypeError("transparency must be an array of 2 dimensions" " (shape is %r)" % transparency.shape)
     if isinstance(pov, int):
-        raise TypeError(
-            "The tcod.map.compute_fov function has changed.  The `x` and `y`"
-            " parameters should now be given as a single tuple."
-        )
+        msg = "The tcod.map.compute_fov function has changed.  The `x` and `y` parameters should now be given as a single tuple."
+        raise TypeError(msg)
     if not (0 <= pov[0] < transparency.shape[0] and 0 <= pov[1] < transparency.shape[1]):
         warnings.warn(
-            "Given pov index %r is outside the array of shape %r."
-            "\nThis will raise an error in future versions." % (pov, transparency.shape),
+            "Given pov index {!r} is outside the array of shape {!r}."
+            "\nThis will raise an error in future versions.".format(pov, transparency.shape),
             RuntimeWarning,
             stacklevel=2,
         )

tcod/noise.py

@@ -30,20 +30,19 @@
            [ 92,  35,  33,  71,  90],
            [ 76,  54,  85, 144, 164],
            [ 63,  94, 159, 209, 203]], dtype=uint8)
-"""  # noqa: E501
+"""
 from __future__ import annotations
 
 import enum
 import warnings
-from typing import Any, List, Optional, Sequence, Tuple, Union
+from typing import Any, Sequence
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 from typing_extensions import Literal
 
 import tcod.constants
 import tcod.random
-from tcod._internal import deprecate
 from tcod.loader import ffi, lib
 
 
@@ -92,14 +91,15 @@ def __getattr__(name: str) -> Implementation:
     if name in Implementation.__members__:
         warnings.warn(
             f"'tcod.noise.{name}' is deprecated," f" use 'tcod.noise.Implementation.{name}' instead.",
-            DeprecationWarning,
+            FutureWarning,
             stacklevel=2,
         )
         return Implementation[name]
-    raise AttributeError(f"module {__name__} has no attribute {name}")
+    msg = f"module {__name__} has no attribute {name}"
+    raise AttributeError(msg)
 
 
-class Noise(object):
+class Noise:
     """A configurable noise sampler.
 
     The ``hurst`` exponent describes the raggedness of the resultant noise,
@@ -130,10 +130,11 @@ def __init__(
         hurst: float = 0.5,
         lacunarity: float = 2.0,
         octaves: float = 4,
-        seed: Optional[Union[int, tcod.random.Random]] = None,
-    ):
+        seed: int | tcod.random.Random | None = None,
+    ) -> None:
         if not 0 < dimensions <= 4:
-            raise ValueError("dimensions must be in range 0 < n <= 4, got %r" % (dimensions,))
+            msg = f"dimensions must be in range 0 < n <= 4, got {dimensions}"
+            raise ValueError(msg)
         self._seed = seed
         self._random = self.__rng_from_seed(seed)
         _random_c = self._random.random_c
@@ -149,7 +150,7 @@ def __init__(
         self.implementation = implementation  # sanity check
 
     @staticmethod
-    def __rng_from_seed(seed: Union[None, int, tcod.random.Random]) -> tcod.random.Random:
+    def __rng_from_seed(seed: None | int | tcod.random.Random) -> tcod.random.Random:
         if seed is None or isinstance(seed, int):
             return tcod.random.Random(seed=seed, algorithm=tcod.random.MERSENNE_TWISTER)
         return seed
@@ -174,11 +175,6 @@ def __repr__(self) -> str:
     def dimensions(self) -> int:
         return int(self._tdl_noise_c.dimensions)
 
-    @property
-    @deprecate("This is a misspelling of 'dimensions'.", FutureWarning)
-    def dimentions(self) -> int:
-        return self.dimensions
-
     @property
     def algorithm(self) -> int:
         noise_type = self.noise_c.noise_type
@@ -195,7 +191,8 @@ def implementation(self) -> int:
     @implementation.setter
     def implementation(self, value: int) -> None:
         if not 0 <= value < 3:
-            raise ValueError("%r is not a valid implementation. " % (value,))
+            msg = f"{value!r} is not a valid implementation. "
+            raise ValueError(msg)
         self._tdl_noise_c.implementation = value
 
     @property
@@ -242,7 +239,8 @@ def __getitem__(self, indexes: Any) -> NDArray[np.float32]:
         c_input = [ffi.NULL, ffi.NULL, ffi.NULL, ffi.NULL]
         for i, index in enumerate(indexes):
             if index.dtype.type == np.object_:
-                raise TypeError("Index arrays can not be of dtype np.object_.")
+                msg = "Index arrays can not be of dtype np.object_."
+                raise TypeError(msg)
             indexes[i] = np.ascontiguousarray(index, dtype=np.float32)
             c_input[i] = ffi.from_buffer("float*", indexes[i])
 
@@ -296,12 +294,12 @@ def sample_mgrid(self, mgrid: ArrayLike) -> NDArray[np.float32]:
         """
         mgrid = np.ascontiguousarray(mgrid, np.float32)
         if mgrid.shape[0] != self.dimensions:
-            raise ValueError(
-                "mgrid.shape[0] must equal self.dimensions, " "%r[0] != %r" % (mgrid.shape, self.dimensions)
-            )
+            msg = f"mgrid.shape[0] must equal self.dimensions, {mgrid.shape!r}[0] != {self.dimensions!r}"
+            raise ValueError(msg)
         out: np.ndarray[Any, np.dtype[np.float32]] = np.ndarray(mgrid.shape[1:], np.float32)
         if mgrid.shape[1:] != out.shape:
-            raise ValueError("mgrid.shape[1:] must equal out.shape, " "%r[1:] != %r" % (mgrid.shape, out.shape))
+            msg = f"mgrid.shape[1:] must equal out.shape, {mgrid.shape!r}[1:] != {out.shape!r}"
+            raise ValueError(msg)
         lib.NoiseSampleMeshGrid(
             self._tdl_noise_c,
             out.size,
@@ -323,8 +321,9 @@ def sample_ogrid(self, ogrid: Sequence[ArrayLike]) -> NDArray[np.float32]:
             The ``dtype`` is `numpy.float32`.
         """
         if len(ogrid) != self.dimensions:
-            raise ValueError("len(ogrid) must equal self.dimensions, " "%r != %r" % (len(ogrid), self.dimensions))
-        ogrids: List[NDArray[np.float32]] = [np.ascontiguousarray(array, np.float32) for array in ogrid]
+            msg = f"len(ogrid) must equal self.dimensions, {len(ogrid)!r} != {self.dimensions!r}"
+            raise ValueError(msg)
+        ogrids: list[NDArray[np.float32]] = [np.ascontiguousarray(array, np.float32) for array in ogrid]
         out: np.ndarray[Any, np.dtype[np.float32]] = np.ndarray([array.size for array in ogrids], np.float32)
         lib.NoiseSampleOpenMeshGrid(
             self._tdl_noise_c,
@@ -335,7 +334,7 @@ def sample_ogrid(self, ogrid: Sequence[ArrayLike]) -> NDArray[np.float32]:
         )
         return out
 
-    def __getstate__(self) -> Any:
+    def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
         if self.dimensions < 4 and self.noise_c.waveletTileData == ffi.NULL:
             # Trigger a side effect of wavelet, so that copies will be synced.
@@ -366,7 +365,7 @@ def __getstate__(self) -> Any:
         }
         return state
 
-    def __setstate__(self, state: Any) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         if isinstance(state, tuple):  # deprecated format
             return self._setstate_old(state)
         # unpack wavelet tile data if it exists
@@ -384,6 +383,7 @@ def __setstate__(self, state: Any) -> None:
         state["_tdl_noise_c"]["noise"] = state["noise_c"]
         state["_tdl_noise_c"] = ffi.new("TDLNoise*", state["_tdl_noise_c"])
         self.__dict__.update(state)
+        return None
 
     def _setstate_old(self, state: Any) -> None:
         self._random = state[0]
@@ -403,11 +403,11 @@ def _setstate_old(self, state: Any) -> None:
 
 
 def grid(
-    shape: Tuple[int, ...],
-    scale: Union[Tuple[float, ...], float],
-    origin: Optional[Tuple[int, ...]] = None,
+    shape: tuple[int, ...],
+    scale: tuple[float, ...] | float,
+    origin: tuple[int, ...] | None = None,
     indexing: Literal["ij", "xy"] = "xy",
-) -> Tuple[NDArray[Any], ...]:
+) -> tuple[NDArray[Any], ...]:
     """Generate a mesh-grid of sample points to use with noise sampling.
 
     Args:
@@ -444,14 +444,16 @@ def grid(
               dtype=float32)
 
     .. versionadded:: 12.2
-    """  # noqa: E501
+    """
     if isinstance(scale, float):
         scale = (scale,) * len(shape)
     if origin is None:
         origin = (0,) * len(shape)
     if len(shape) != len(scale):
-        raise TypeError("shape must have the same length as scale")
+        msg = "shape must have the same length as scale"
+        raise TypeError(msg)
     if len(shape) != len(origin):
-        raise TypeError("shape must have the same length as origin")
+        msg = "shape must have the same length as origin"
+        raise TypeError(msg)
     indexes = (np.arange(i_shape) * i_scale + i_origin for i_shape, i_scale, i_origin in zip(shape, scale, origin))
     return tuple(np.meshgrid(*indexes, copy=False, sparse=True, indexing=indexing))