Update NumPy type hints.

Author: HexDecimal

examples/cavegen.py

@@ -6,11 +6,14 @@
 This will print the result to the console, so be sure to run this from the
 command line.
 """
+from typing import Any
+
 import numpy as np
 import scipy.signal  # type: ignore
+from numpy.typing import NDArray
 
 
-def convolve(tiles: np.ndarray, wall_rule: int = 5) -> np.ndarray:
+def convolve(tiles: NDArray[Any], wall_rule: int = 5) -> NDArray[np.bool_]:
     """Return the next step of the cave generation algorithm.
 
     `tiles` is the input array. (0: wall, 1: floor)
@@ -19,12 +22,12 @@ def convolve(tiles: np.ndarray, wall_rule: int = 5) -> np.ndarray:
     walls then the tile will become a wall.
     """
     # Use convolve2d, the 2nd input is a 3x3 ones array.
-    neighbors: np.ndarray = scipy.signal.convolve2d(tiles == 0, [[1, 1, 1], [1, 1, 1], [1, 1, 1]], "same")
-    next_tiles: np.ndarray = neighbors < wall_rule  # Apply the wall rule.
+    neighbors: NDArray[Any] = scipy.signal.convolve2d(tiles == 0, [[1, 1, 1], [1, 1, 1], [1, 1, 1]], "same")
+    next_tiles: NDArray[np.bool_] = neighbors < wall_rule  # Apply the wall rule.
     return next_tiles
 
 
-def show(tiles: np.ndarray) -> None:
+def show(tiles: NDArray[Any]) -> None:
     """Print out the tiles of an array."""
     for line in tiles:
         print("".join("# "[int(cell)] for cell in line))
@@ -35,7 +38,7 @@ def show(tiles: np.ndarray) -> None:
     INITIAL_CHANCE = 0.45  # Initial wall chance.
     CONVOLVE_STEPS = 4
     # 0: wall, 1: floor
-    tiles = np.random.random((HEIGHT, WIDTH)) > INITIAL_CHANCE
+    tiles: NDArray[np.bool_] = np.random.random((HEIGHT, WIDTH)) > INITIAL_CHANCE
     for _ in range(CONVOLVE_STEPS):
         tiles = convolve(tiles)
         tiles[[0, -1], :] = 0  # Ensure surrounding wall.

examples/samples_tcod.py

@@ -18,6 +18,7 @@
 
 import numpy as np
 import tcod
+from numpy.typing import NDArray
 
 if not sys.warnoptions:
     warnings.simplefilter("default")  # Show all warnings.
@@ -839,51 +840,51 @@ def ev_mousemotion(self, event: tcod.event.MouseMotion) -> None:
 
 
 # draw a vertical line
-def vline(m: np.ndarray, x: int, y1: int, y2: int) -> None:
+def vline(m: NDArray[np.bool_], x: int, y1: int, y2: int) -> None:
     if y1 > y2:
         y1, y2 = y2, y1
     for y in range(y1, y2 + 1):
         m[x, y] = True
 
 
 # draw a vertical line up until we reach an empty space
-def vline_up(m: np.ndarray, x: int, y: int) -> None:
+def vline_up(m: NDArray[np.bool_], x: int, y: int) -> None:
     while y >= 0 and not m[x, y]:
         m[x, y] = True
         y -= 1
 
 
 # draw a vertical line down until we reach an empty space
-def vline_down(m: np.ndarray, x: int, y: int) -> None:
+def vline_down(m: NDArray[np.bool_], x: int, y: int) -> None:
     while y < SAMPLE_SCREEN_HEIGHT and not m[x, y]:
         m[x, y] = True
         y += 1
 
 
 # draw a horizontal line
-def hline(m: np.ndarray, x1: int, y: int, x2: int) -> None:
+def hline(m: NDArray[np.bool_], x1: int, y: int, x2: int) -> None:
     if x1 > x2:
         x1, x2 = x2, x1
     for x in range(x1, x2 + 1):
         m[x, y] = True
 
 
 # draw a horizontal line left until we reach an empty space
-def hline_left(m: np.ndarray, x: int, y: int) -> None:
+def hline_left(m: NDArray[np.bool_], x: int, y: int) -> None:
     while x >= 0 and not m[x, y]:
         m[x, y] = True
         x -= 1
 
 
 # draw a horizontal line right until we reach an empty space
-def hline_right(m: np.ndarray, x: int, y: int) -> None:
+def hline_right(m: NDArray[np.bool_], x: int, y: int) -> None:
     while x < SAMPLE_SCREEN_WIDTH and not m[x, y]:
         m[x, y] = True
         x += 1
 
 
 # the class building the dungeon from the bsp nodes
-def traverse_node(bsp_map: np.ndarray, node: tcod.bsp.BSP) -> None:
+def traverse_node(bsp_map: NDArray[np.bool_], node: tcod.bsp.BSP) -> None:
     if not node.children:
         # calculate the room size
         if bsp_room_walls:
@@ -1216,7 +1217,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))
+    (xc, yc) = np.meshgrid(range(SCREEN_W), range(SCREEN_H))  # type: ignore
     # translate coordinates of all pixels to center
     xc = xc - HALF_W
     yc = yc - HALF_H

tcod/console.py

@@ -110,7 +110,7 @@ def __init__(
         width: int,
         height: int,
         order: Literal["C", "F"] = "C",
-        buffer: Optional[np.ndarray] = None,
+        buffer: "Optional[np.ndarray[Any, Any]]" = None,
     ):
         self._key_color = None  # type: Optional[Tuple[int, int, int]]
         self._order = tcod._internal.verify_order(order)
@@ -181,7 +181,7 @@ def _init_setup_console_data(self, order: Literal["C", "F"] = "C") -> None:
         else:
             self._console_data = ffi.cast("struct TCOD_Console*", self.console_c)
 
-        self._tiles = np.frombuffer(
+        self._tiles = np.frombuffer(  # type: ignore
             ffi.buffer(self._console_data.tiles[0 : self.width * self.height]),
             dtype=self.DTYPE,
         ).reshape((self.height, self.width))
@@ -199,7 +199,7 @@ def height(self) -> int:
         return lib.TCOD_console_get_height(self.console_c)  # type: ignore
 
     @property
-    def bg(self) -> np.ndarray:
+    def bg(self) -> "np.ndarray[Any, np.dtype[np.uint8]]":
         """A uint8 array with the shape (height, width, 3).
 
         You can change the consoles background colors by using this array.
@@ -208,27 +208,27 @@ def bg(self) -> np.ndarray:
         ``console.bg[x, y, channel]  # order='F'``.
 
         """
-        bg = self._tiles["bg"][..., :3]  # type: np.ndarray
+        bg: np.ndarray[Any, np.dtype[np.uint8]] = self._tiles["bg"][..., :3]
         if self._order == "F":
             bg = bg.transpose(1, 0, 2)
         return bg
 
     @property
-    def fg(self) -> np.ndarray:
+    def fg(self) -> "np.ndarray[Any, np.dtype[np.uint8]]":
         """A uint8 array with the shape (height, width, 3).
 
         You can change the consoles foreground colors by using this array.
 
         Index this array with ``console.fg[i, j, channel]  # order='C'`` or
         ``console.fg[x, y, channel]  # order='F'``.
         """
-        fg = self._tiles["fg"][..., :3]  # type: np.ndarray
+        fg: np.ndarray[Any, np.dtype[np.uint8]] = self._tiles["fg"][..., :3]
         if self._order == "F":
             fg = fg.transpose(1, 0, 2)
         return fg
 
     @property
-    def ch(self) -> np.ndarray:
+    def ch(self) -> "np.ndarray[Any, np.dtype[np.intc]]":
         """An integer array with the shape (height, width).
 
         You can change the consoles character codes by using this array.
@@ -240,7 +240,7 @@ def ch(self) -> np.ndarray:
 
     @property  # type: ignore
     @deprecate("This attribute has been renamed to `rgba`.")
-    def tiles(self) -> np.ndarray:
+    def tiles(self) -> "np.ndarray[Any, Any]":
         """An array of this consoles raw tile data.
 
         This acts as a combination of the `ch`, `fg`, and `bg` attributes.
@@ -256,7 +256,7 @@ def tiles(self) -> np.ndarray:
 
     @property  # type: ignore
     @deprecate("This attribute has been renamed to `rgba`.")
-    def buffer(self) -> np.ndarray:
+    def buffer(self) -> "np.ndarray[Any, Any]":
         """An array of this consoles raw tile data.
 
         .. versionadded:: 11.4
@@ -268,7 +268,7 @@ def buffer(self) -> np.ndarray:
 
     @property  # type: ignore
     @deprecate("This attribute has been renamed to `rgb`.")
-    def tiles_rgb(self) -> np.ndarray:
+    def tiles_rgb(self) -> "np.ndarray[Any, Any]":
         """An array of this consoles data without the alpha channel.
 
         .. versionadded:: 11.8
@@ -280,7 +280,7 @@ def tiles_rgb(self) -> np.ndarray:
 
     @property  # type: ignore
     @deprecate("This attribute has been renamed to `rgb`.")
-    def tiles2(self) -> np.ndarray:
+    def tiles2(self) -> "np.ndarray[Any, Any]":
         """This name is deprecated in favour of :any:`rgb`.
 
         .. versionadded:: 11.3
@@ -291,7 +291,7 @@ def tiles2(self) -> np.ndarray:
         return self.rgb
 
     @property
-    def rgba(self) -> np.ndarray:
+    def rgba(self) -> "np.ndarray[Any, Any]":
         """An array of this consoles raw tile data.
 
         The axes of this array is affected by the `order` parameter given to
@@ -312,7 +312,7 @@ def rgba(self) -> np.ndarray:
         return self._tiles.T if self._order == "F" else self._tiles
 
     @property
-    def rgb(self) -> np.ndarray:
+    def rgb(self) -> "np.ndarray[Any, Any]":
         """An array of this consoles data without the alpha channel.
 
         The axes of this array is affected by the `order` parameter given to
@@ -888,13 +888,13 @@ def __getstate__(self) -> Any:
             "back": self.default_bg,
         }
         if self.console_c == ffi.NULL:
-            state["_tiles"] = np.copy(self._tiles)
+            state["_tiles"] = np.array(self._tiles, copy=True)
         return state
 
     def __setstate__(self, state: Any) -> None:
         self._key_color = None
         if "_tiles" not in state:
-            tiles = np.ndarray((self.height, self.width), dtype=self.DTYPE)
+            tiles: np.ndarray[Any, Any] = np.ndarray((self.height, self.width), dtype=self.DTYPE)
             tiles["ch"] = state["_ch"]
             tiles["fg"][..., :3] = state["_fg"]
             tiles["fg"][..., 3] = 255

tcod/event.py

@@ -1030,7 +1030,7 @@ def _pycall_event_watch(userdata: Any, sdl_event: Any) -> int:
     return 0
 
 
-def get_keyboard_state() -> np.ndarray:
+def get_keyboard_state() -> "np.ndarray[Any, np.dtype[np.bool_]]":
     """Return a boolean array with the current keyboard state.
 
     Index this array with a scancode.  The value will be True if the key is
@@ -1052,7 +1052,7 @@ def get_keyboard_state() -> np.ndarray:
     """
     numkeys = ffi.new("int[1]")
     keyboard_state = lib.SDL_GetKeyboardState(numkeys)
-    out: np.ndarray = np.frombuffer(ffi.buffer(keyboard_state[0 : numkeys[0]]), dtype=bool)
+    out: np.ndarray[Any, Any] = np.frombuffer(ffi.buffer(keyboard_state[0 : numkeys[0]]), dtype=bool)  # type: ignore
     out.flags["WRITEABLE"] = False  # This buffer is supposed to be const.
     return out
 

tcod/image.py

@@ -333,7 +333,7 @@ def _get_format_name(format: int) -> str:
     "  It's recommended to load images with a more complete image library such as python-Pillow or python-imageio.",
     category=PendingDeprecationWarning,
 )
-def load(filename: Union[str, Path]) -> np.ndarray:
+def load(filename: Union[str, Path]) -> "np.ndarray[Any, np.dtype[np.uint8]]":
     """Load a PNG file as an RGBA array.
 
     `filename` is the name of the file to load.
@@ -346,7 +346,7 @@ def load(filename: Union[str, Path]) -> np.ndarray:
     array = np.asarray(image, dtype=np.uint8)
     height, width, depth = array.shape
     if depth == 3:
-        array = np.concatenate(
+        array = np.concatenate(  # type: ignore
             (
                 array,
                 np.full((height, width, 1), fill_value=255, dtype=np.uint8),