Update Numpy type hints.

Author: HexDecimal

examples/samples_tcod.py

@@ -14,7 +14,7 @@
 import sys
 import time
 import warnings
-from typing import List
+from typing import Any, List
 
 import numpy as np
 import tcod
@@ -101,14 +101,14 @@ class TrueColorSample(Sample):
     def __init__(self) -> None:
         self.name = "True colors"
         # corner colors
-        self.colors = np.array(
+        self.colors: NDArray[np.int16] = np.array(
             [(50, 40, 150), (240, 85, 5), (50, 35, 240), (10, 200, 130)],
             dtype=np.int16,
         )
         # color shift direction
-        self.slide_dir = np.array([[1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, -1]], dtype=np.int16)
+        self.slide_dir: NDArray[np.int16] = np.array([[1, 1, 1], [-1, -1, 1], [1, -1, 1], [1, 1, -1]], dtype=np.int16)
         # corner indexes
-        self.corners = np.array([0, 1, 2, 3])
+        self.corners: NDArray[np.int16] = np.array([0, 1, 2, 3], dtype=np.int16)
 
     def on_draw(self) -> None:
         self.slide_corner_colors()
@@ -509,7 +509,7 @@ def ev_keydown(self, event: tcod.event.KeyDown) -> None:
     "##############################################",
 ]
 
-SAMPLE_MAP = np.array([list(line) for line in SAMPLE_MAP_]).transpose()
+SAMPLE_MAP: NDArray[Any] = np.array([list(line) for line in SAMPLE_MAP_]).transpose()
 
 FOV_ALGO_NAMES = [
     "BASIC      ",
@@ -545,17 +545,17 @@ def __init__(self) -> None:
 
         map_shape = (SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)
 
-        self.walkable = np.zeros(map_shape, dtype=bool, order="F")
+        self.walkable: NDArray[np.bool_] = np.zeros(map_shape, dtype=bool, order="F")
         self.walkable[:] = SAMPLE_MAP[:] == " "
 
-        self.transparent = np.zeros(map_shape, dtype=bool, order="F")
+        self.transparent: NDArray[np.bool_] = np.zeros(map_shape, dtype=bool, order="F")
         self.transparent[:] = self.walkable[:] | (SAMPLE_MAP == "=")
 
         # Lit background colors for the map.
-        self.light_map_bg = np.full(SAMPLE_MAP.shape, LIGHT_GROUND, dtype="3B")
+        self.light_map_bg: NDArray[np.uint8] = np.full(SAMPLE_MAP.shape, LIGHT_GROUND, dtype="3B")
         self.light_map_bg[SAMPLE_MAP[:] == "#"] = LIGHT_WALL
         # Dark background colors for the map.
-        self.dark_map_bg = np.full(SAMPLE_MAP.shape, DARK_GROUND, dtype="3B")
+        self.dark_map_bg: NDArray[np.uint8] = np.full(SAMPLE_MAP.shape, DARK_GROUND, dtype="3B")
         self.dark_map_bg[SAMPLE_MAP[:] == "#"] = DARK_WALL
 
     def draw_ui(self) -> None:
@@ -948,7 +948,7 @@ class BSPSample(Sample):
     def __init__(self) -> None:
         self.name = "Bsp toolkit"
         self.bsp = tcod.bsp.BSP(1, 1, SAMPLE_SCREEN_WIDTH - 1, SAMPLE_SCREEN_HEIGHT - 1)
-        self.bsp_map = np.zeros((SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT), dtype=bool, order="F")
+        self.bsp_map: NDArray[np.bool_] = np.zeros((SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT), dtype=bool, order="F")
         self.bsp_generate()
 
     def bsp_generate(self) -> None:
@@ -1214,7 +1214,7 @@ def ev_keydown(self, event: tcod.event.KeyDown) -> None:
 # xc = [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
 # yc = [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]]
 if numpy_available:
-    (xc, yc) = np.meshgrid(range(SCREEN_W), range(SCREEN_H))  # type: ignore
+    (xc, yc) = np.meshgrid(range(SCREEN_W), range(SCREEN_H))
     # translate coordinates of all pixels to center
     xc = xc - HALF_W
     yc = yc - HALF_H

examples/ttf.py

@@ -13,6 +13,7 @@
 import freetype  # type: ignore  # pip install freetype-py
 import numpy as np
 import tcod
+from numpy.typing import NDArray
 
 FONT = "VeraMono.ttf"
 
@@ -36,10 +37,10 @@ def load_ttf(path: str, size: Tuple[int, int]) -> tcod.tileset.Tileset:
         ttf.load_glyph(glyph_index)
         bitmap = ttf.glyph.bitmap
         assert bitmap.pixel_mode == freetype.FT_PIXEL_MODE_GRAY
-        bitmap_array = np.asarray(bitmap.buffer).reshape((bitmap.width, bitmap.rows), order="F")
+        bitmap_array: NDArray[np.uint8] = np.asarray(bitmap.buffer).reshape((bitmap.width, bitmap.rows), order="F")
         if bitmap_array.size == 0:
             continue  # Skip blank glyphs.
-        output_image = np.zeros(size, dtype=np.uint8, order="F")
+        output_image: NDArray[np.uint8] = np.zeros(size, dtype=np.uint8, order="F")
         out_slice = output_image
 
         # Adjust the position to center this glyph on the tile.

tcod/_internal.py

@@ -7,6 +7,7 @@
 from typing import Any, AnyStr, Callable, TypeVar, cast
 
 import numpy as np
+from numpy.typing import NDArray
 from typing_extensions import Literal, NoReturn
 
 from tcod.loader import ffi, lib
@@ -225,7 +226,7 @@ class TempImage(object):
     """An Image-like container for NumPy arrays."""
 
     def __init__(self, array: Any):
-        self._array = np.ascontiguousarray(array, dtype=np.uint8)
+        self._array: NDArray[np.uint8] = np.ascontiguousarray(array, dtype=np.uint8)
         height, width, depth = self._array.shape
         if depth != 3:
             raise TypeError("Array must have RGB channels.  Shape is: %r" % (self._array.shape,))

tcod/console.py

@@ -124,7 +124,7 @@ def __init__(
         if buffer is not None:
             if self._order == "F":
                 buffer = buffer.transpose()
-            self._tiles = np.ascontiguousarray(buffer, self.DTYPE)
+            self._tiles: NDArray[Any] = np.ascontiguousarray(buffer, self.DTYPE)
         else:
             self._tiles = np.ndarray((height, width), dtype=self.DTYPE)
 

tcod/event.py

@@ -1091,8 +1091,8 @@ def get_keyboard_state() -> NDArray[np.bool_]:
     """
     numkeys = ffi.new("int[1]")
     keyboard_state = lib.SDL_GetKeyboardState(numkeys)
-    out: NDArray[np.bool_] = np.frombuffer(ffi.buffer(keyboard_state[0 : numkeys[0]]), dtype=np.bool_)  # type: ignore
-    out.flags["WRITEABLE"] = False  # This buffer is supposed to be const.
+    out: NDArray[np.bool_] = np.frombuffer(ffi.buffer(keyboard_state[0 : numkeys[0]]), dtype=np.bool_)
+    out.flags["WRITEABLE"] = False  # type: ignore[index]  # This buffer is supposed to be const.
     return out
 
 

tcod/image.py

@@ -11,7 +11,7 @@
 from typing import Any, Dict, Tuple, Union
 
 import numpy as np
-from numpy.typing import NDArray
+from numpy.typing import ArrayLike, NDArray
 
 import tcod.console
 from tcod._internal import _console, deprecate
@@ -41,7 +41,7 @@ def _from_cdata(cls, cdata: Any) -> Image:
         return self
 
     @classmethod
-    def from_array(cls, array: Any) -> Image:
+    def from_array(cls, array: ArrayLike) -> Image:
         """Create a new Image from a copy of an array-like object.
 
         Example:
@@ -52,10 +52,10 @@ def from_array(cls, array: Any) -> Image:
 
         .. versionadded:: 11.4
         """
-        array = np.asarray(array)
+        array = np.asarray(array, dtype=np.uint8)
         height, width, depth = array.shape
         image = cls(width, height)
-        image_array = np.asarray(image)
+        image_array: NDArray[np.uint8] = np.asarray(image)
         image_array[...] = array
         return image
 
@@ -349,7 +349,7 @@ def load(filename: Union[str, PathLike[str]]) -> NDArray[np.uint8]:
     array: NDArray[np.uint8] = np.asarray(image, dtype=np.uint8)
     height, width, depth = array.shape
     if depth == 3:
-        array = np.concatenate(  # type: ignore
+        array = np.concatenate(
             (
                 array,
                 np.full((height, width, 1), fill_value=255, dtype=np.uint8),

tcod/libtcodpy.py

@@ -2305,7 +2305,7 @@ def _heightmap_cdata(array: NDArray[np.float32]) -> ffi.CData:
         array = array.transpose()
     if not array.flags["C_CONTIGUOUS"]:
         raise ValueError("array must be a contiguous segment.")
-    if array.dtype != np.float32:  # type: ignore
+    if array.dtype != np.float32:
         raise ValueError("array dtype must be float32, not %r" % array.dtype)
     height, width = array.shape
     pointer = ffi.from_buffer("float *", array)

tcod/map.py

@@ -87,7 +87,7 @@ def __init__(
         self.height = height
         self._order = tcod._internal.verify_order(order)
 
-        self.__buffer = np.zeros((height, width, 3), dtype=np.bool_)
+        self.__buffer: NDArray[np.bool_] = np.zeros((height, width, 3), dtype=np.bool_)
         self.map_c = self.__as_cdata()
 
     def __as_cdata(self) -> Any:
@@ -251,7 +251,7 @@ def compute_fov(
             RuntimeWarning,
             stacklevel=2,
         )
-    map_buffer = np.empty(
+    map_buffer: NDArray[np.bool_] = np.empty(
         transparency.shape,
         dtype=[("transparent", bool), ("walkable", bool), ("fov", bool)],
     )

tcod/noise.py

@@ -38,7 +38,7 @@
 
 import enum
 import warnings
-from typing import Any, Optional, Sequence, Tuple, Union
+from typing import Any, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -245,15 +245,15 @@ def __getitem__(self, indexes: Any) -> NDArray[np.float32]:
             raise IndexError(
                 "This noise generator has %i dimensions, but was indexed with %i." % (self.dimensions, len(indexes))
             )
-        indexes = np.broadcast_arrays(*indexes)  # type: ignore
+        indexes = np.broadcast_arrays(*indexes)
         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_.")
             indexes[i] = np.ascontiguousarray(index, dtype=np.float32)
             c_input[i] = ffi.from_buffer("float*", indexes[i])
 
-        out = np.empty(indexes[0].shape, dtype=np.float32)
+        out: NDArray[np.float32] = np.empty(indexes[0].shape, dtype=np.float32)
         if self.implementation == Implementation.SIMPLE:
             lib.TCOD_noise_get_vectorized(
                 self.noise_c,
@@ -332,7 +332,7 @@ def sample_ogrid(self, ogrid: Sequence[ArrayLike]) -> NDArray[np.float32]:
         """
         if len(ogrid) != self.dimensions:
             raise ValueError("len(ogrid) must equal self.dimensions, " "%r != %r" % (len(ogrid), self.dimensions))
-        ogrids = [np.ascontiguousarray(array, np.float32) for array in ogrid]
+        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,
@@ -461,4 +461,4 @@ def grid(
     if len(shape) != len(origin):
         raise TypeError("shape must have the same length as origin")
     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))  # type: ignore
+    return tuple(np.meshgrid(*indexes, copy=False, sparse=True, indexing=indexing))

tcod/path.py

@@ -473,7 +473,7 @@ def dijkstra2d(
     .. versionchanged:: 12.1
         Added `out` parameter.  Now returns the output array.
     """
-    dist = np.asarray(distance)
+    dist: NDArray[Any] = np.asarray(distance)
     if out is ...:  # type: ignore
         out = dist
         warnings.warn(
@@ -560,7 +560,7 @@ def hillclimb2d(
         Added `edge_map` parameter.
     """
     x, y = start
-    dist = np.asarray(distance)
+    dist: NDArray[Any] = np.asarray(distance)
     if not (0 <= x < dist.shape[0] and 0 <= y < dist.shape[1]):
         raise IndexError("Starting point %r not in shape %r" % (start, dist.shape))
     c_dist = _export(dist)
@@ -582,7 +582,7 @@ def _world_array(shape: Tuple[int, ...], dtype: Any = np.int32) -> NDArray[Any]:
     """Return an array where ``ij == arr[ij]``."""
     return np.ascontiguousarray(
         np.transpose(
-            np.meshgrid(  # type: ignore
+            np.meshgrid(
                 *(np.arange(i, dtype=dtype) for i in shape),
                 indexing="ij",
                 copy=False,