Deprecate support for Python 3.5.

Use typing_extensions to better support types on older versions of
Python.  This version actually supports 3.5 better than previous
versions, which makes it a better point to drop support from.

Author: HexDecimal

CHANGELOG.rst

@@ -11,6 +11,7 @@ Unreleased
 Deprecated
  - `tcod.console_load_xp` has been deprecated, `tcod.console_from_xp` can load
    these files without modifying an existing console.
+ - Support for Python 3.5 will be dropped soon.
 
 Fixed
  - `tcod.console_from_xp` now has better error handling (instead of crashing.)

setup.py

@@ -135,6 +135,7 @@ def check_sdl_version():
     install_requires=[
         "cffi~=1.13",  # Also required by pyproject.toml.
         "numpy~=1.10" if not is_pypy else "",
+        "typing_extensions",
     ],
     cffi_modules=["build_libtcod.py:ffi"],
     setup_requires=pytest_runner,

tcod/__init__.py

@@ -15,6 +15,9 @@
     Bring any issues or requests to GitHub:
     https://github.com/HexDecimal/libtcod-cffi
 """
+import sys
+import warnings
+
 from tcod import (
     bsp,
     color,
@@ -39,6 +42,13 @@
 except ImportError:  # Gets imported without version.py by ReadTheDocs
     __version__ = ""
 
+if sys.version_info < (3, 6):
+    warnings.warn(
+        "Support for Python 3.5 is being dropped from python-tcod.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
 __all__ = [  # noqa: F405
     "__version__",
     "lib",

tcod/_internal.py

@@ -2,9 +2,10 @@
 """
 import functools
 import warnings
-from typing import Any, AnyStr, Callable, NoReturn, TypeVar, cast
+from typing import Any, AnyStr, Callable, TypeVar, Union, cast
 
 import numpy as np
+from typing_extensions import Literal, NoReturn
 
 from tcod.loader import ffi, lib
 
@@ -42,21 +43,15 @@ def pending_deprecate(
     return deprecate(message, category, stacklevel)
 
 
-def verify_order(order: str) -> str:
-    order = order.upper()
+def verify_order(
+    order: Union[Literal["C"], Literal["F"]]
+) -> Union[Literal["C"], Literal["F"]]:
+    order = order.upper()  # type: ignore
     if order not in ("C", "F"):
         raise TypeError("order must be 'C' or 'F', not %r" % (order,))
     return order
 
 
-def handle_order(shape: Any, order: str) -> Any:
-    order = verify_order(order)
-    if order == "C":
-        return shape
-    else:
-        return tuple(reversed(shape))
-
-
 def _raise_tcod_error() -> NoReturn:
     """Raise an error from libtcod, this function assumes an error exists."""
     raise RuntimeError(ffi.string(lib.TCOD_get_error()).decode("utf-8"))

tcod/console.py

@@ -5,9 +5,10 @@
 """
 
 import warnings
-from typing import Any, Optional, Tuple  # noqa: F401
+from typing import Any, Optional, Tuple, Union  # noqa: F401
 
 import numpy as np
+from typing_extensions import Literal
 
 import tcod._internal
 import tcod.constants
@@ -92,7 +93,7 @@ def __init__(
         self,
         width: int,
         height: int,
-        order: str = "C",
+        order: Union[Literal["C"], Literal["F"]] = "C",
         buffer: Optional[np.ndarray] = None,
     ):
         self._key_color = None  # type: Optional[Tuple[int, int, int]]
@@ -131,7 +132,9 @@ def __init__(
             self.clear()
 
     @classmethod
-    def _from_cdata(cls, cdata: Any, order: str = "C") -> "Console":
+    def _from_cdata(
+        cls, cdata: Any, order: Union[Literal["C"], Literal["F"]] = "C"
+    ) -> "Console":
         """Return a Console instance which wraps this `TCOD_Console*` object."""
         if isinstance(cdata, cls):
             return cdata
@@ -141,7 +144,9 @@ def _from_cdata(cls, cdata: Any, order: str = "C") -> "Console":
         return self
 
     @classmethod
-    def _get_root(cls, order: Optional[str] = None) -> "Console":
+    def _get_root(
+        cls, order: Optional[Union[Literal["C"], Literal["F"]]] = None
+    ) -> "Console":
         """Return a root console singleton with valid buffers.
 
         This function will also update an already active root console.
@@ -156,7 +161,9 @@ def _get_root(cls, order: Optional[str] = None) -> "Console":
         self._init_setup_console_data(self._order)
         return self
 
-    def _init_setup_console_data(self, order: str = "C") -> None:
+    def _init_setup_console_data(
+        self, order: Union[Literal["C"], Literal["F"]] = "C"
+    ) -> None:
         """Setup numpy arrays over libtcod data buffers."""
         global _root_console
         self._key_color = None
@@ -195,7 +202,7 @@ def bg(self) -> np.ndarray:
         ``console.bg[x, y, channel]  # order='F'``.
 
         """
-        bg = self._tiles["bg"][..., :3]
+        bg = self._tiles["bg"][..., :3]  # type: np.ndarray
         if self._order == "F":
             bg = bg.transpose(1, 0, 2)
         return bg
@@ -209,7 +216,7 @@ def fg(self) -> np.ndarray:
         Index this array with ``console.fg[i, j, channel]  # order='C'`` or
         ``console.fg[x, y, channel]  # order='F'``.
         """
-        fg = self._tiles["fg"][..., :3]
+        fg = self._tiles["fg"][..., :3]  # type: np.ndarray
         if self._order == "F":
             fg = fg.transpose(1, 0, 2)
         return fg

tcod/libtcodpy.py

@@ -20,6 +20,7 @@
 )
 
 import numpy as np
+from typing_extensions import Literal
 
 import tcod.bsp
 import tcod.console
@@ -879,7 +880,7 @@ def console_init_root(
     title: Optional[str] = None,
     fullscreen: bool = False,
     renderer: Optional[int] = None,
-    order: str = "C",
+    order: Union[Literal["C"], Literal["F"]] = "C",
     vsync: Optional[bool] = None,
 ) -> tcod.console.Console:
     """Set up the primary display and return the root console.

tcod/map.py

@@ -3,9 +3,10 @@
 
 """
 import warnings
-from typing import Any, Tuple
+from typing import Any, Tuple, Union
 
 import numpy as np
+from typing_extensions import Literal
 
 import tcod._internal
 import tcod.constants
@@ -68,7 +69,12 @@ class Map(object):
         See :any:`tcod.map.compute_fov` and :any:`tcod.path`.
     """
 
-    def __init__(self, width: int, height: int, order: str = "C"):
+    def __init__(
+        self,
+        width: int,
+        height: int,
+        order: Union[Literal["C"], Literal["F"]] = "C",
+    ):
         warnings.warn(
             "This class may perform poorly and is no longer needed.",
             DeprecationWarning,
@@ -94,17 +100,17 @@ def __as_cdata(self) -> Any:
 
     @property
     def transparent(self) -> np.ndarray:
-        buffer = self.__buffer[:, :, 0]
+        buffer = self.__buffer[:, :, 0]  # type: np.ndarray
         return buffer.T if self._order == "F" else buffer
 
     @property
     def walkable(self) -> np.ndarray:
-        buffer = self.__buffer[:, :, 1]
+        buffer = self.__buffer[:, :, 1]  # type: np.ndarray
         return buffer.T if self._order == "F" else buffer
 
     @property
     def fov(self) -> np.ndarray:
-        buffer = self.__buffer[:, :, 2]
+        buffer = self.__buffer[:, :, 2]  # type: np.ndarray
         return buffer.T if self._order == "F" else buffer
 
     def compute_fov(

tcod/path.py

@@ -20,6 +20,7 @@
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
+from typing_extensions import Literal
 
 import tcod.map  # noqa: F401
 from tcod._internal import _check
@@ -301,7 +302,9 @@ def get_path(self, x: int, y: int) -> List[Tuple[int, int]]:
 
 
 def maxarray(
-    shape: Tuple[int, ...], dtype: Any = np.int32, order: str = "C"
+    shape: Tuple[int, ...],
+    dtype: Any = np.int32,
+    order: Union[Literal["C"], Literal["F"]] = "C",
 ) -> np.ndarray:
     """Return a new array filled with the maximum finite value for `dtype`.