make source adhere to strict typing from mypy

src/aliasing/core.py

@@ -22,26 +22,28 @@ def __init__(
         self._aliased = _aliased
         self._trample_ok = trample_ok
 
-    def __set_name__(self, owner, name):
+    def __set_name__(self, owner: Any, name: str) -> None:
         self._name = name
 
     @staticmethod
-    def _get_alias_obj(owner, owner_type, name) -> Optional["alias"]:
+    def _get_alias_obj(
+        owner: Any, owner_type: Any, name: str
+    ) -> Optional["alias"]:
         if (
             owner
             and hasattr(owner, "__dict__")
             and isinstance(owner.__dict__.get(name, None), alias)
         ):
-            return owner.__dict__[name]
+            return cast(alias, owner.__dict__[name])
         elif (
             owner_type
             and hasattr(owner_type, "__dict__")
             and isinstance(owner_type.__dict__.get(name, None), alias)
         ):
-            return owner_type.__dict__[name]
+            return cast(alias, owner_type.__dict__[name])
         return None
 
-    def _validate_nested(self, owner, owner_type) -> Any:
+    def _validate_nested(self, owner: Any, owner_type: Any) -> Any:
         # basic 2 ptrs
         p1: Any = self._get_alias_obj(owner, owner_type, self._for)
         p2 = self
@@ -66,7 +68,7 @@ def _validate_nested(self, owner, owner_type) -> Any:
             move_p2 = not move_p2
         return p1
 
-    def __get__(self, owner, owner_type=None):
+    def __get__(self, owner: Any, owner_type: Any = None) -> Any:
         value = None
         if isinstance(
             self._get_alias_obj(owner, owner_type, self._for), alias
@@ -91,18 +93,18 @@ def __get__(self, owner, owner_type=None):
 
         return value
 
-    def __set__(self, owner, value):
+    def __set__(self, owner: Any, value: Any) -> None:
         raise NotImplementedError(
             f"cannot set the value of read-only alias {self._name}"
         )
 
     def attach(
         self,
-        owner,
+        owner: Any,
         name: Optional[str] = None,
         *,
         trample_ok: Optional[bool] = None,
-    ):
+    ) -> None:
         trample_ok = trample_ok if trample_ok is not None else self._trample_ok
         name = name or self._name
         if not name:
@@ -139,7 +141,7 @@ def attach(
 
 
 class aliased:
-    def __init__(self, func):
+    def __init__(self, func: Any):
         self._func = func
         self._aliases: List[alias] = []
         self._original: aliased = self
@@ -175,7 +177,7 @@ def __init__(self, func):
         self._doc = self._init_doc
         self._refresh_doc()
 
-    def _refresh_doc(self):
+    def _refresh_doc(self) -> None:
         alias_list = ",".join(
             filter(
                 None, map(lambda a: getattr(a, "_name", None), self._aliases)
@@ -189,17 +191,17 @@ def _refresh_doc(self):
         )
         self.__doc__ = self._doc
 
-    def _refresh_name(self, name: Optional[str] = None):
+    def _refresh_name(self, name: Optional[str] = None) -> None:
         self._name = name or self._name
         self._private_name = f"_aliased_{self._name}"
 
-    def __set_name__(self, owner, name: str):
+    def __set_name__(self, owner: Any, name: str) -> None:
         self._refresh_name(name)
         func = self._func
         self._init_doc = func.__doc__
         setattr(owner, self._private_name, func)
 
-    def __get__(self, owner, owner_type=None):
+    def __get__(self, owner: Any, owner_type: Any = None) -> Any:
         self._refresh_doc()
         if owner is None:
             try:
@@ -212,7 +214,7 @@ def __get__(self, owner, owner_type=None):
         if callable(func):
 
             @wraps(func)
-            def wrapper(*args, **kwargs):
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
                 return func(*args, **kwargs)
 
             wrapper.__doc__ = self._doc

src/aliasing/example.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from .core import alias, aliased
 
 
@@ -8,17 +10,17 @@ class Example:
 
     my_second_alias = my_aliased.alias()
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.my = 123
 
     @aliased
-    def method(self):
+    def method(self) -> str:
         return "my method call"
 
     method_alias1 = method.alias()
 
     @method.alias
-    def method_alias2(self): ...
+    def method_alias2(self) -> Any: ...
 
 
 if __name__ == "__main__":

src/aliasing/virtual_alias.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import List, Optional
+from typing import List, Optional, Any
 
 from .core import aliased
 from .error import TrampleAliasWarning, TrampleAliasError
@@ -14,7 +14,7 @@ class valiased(aliased):
     """
 
     def __init__(
-        self, func, *aliases: str, trample_ok: Optional[List[str]] = None
+        self, func: Any, *aliases: str, trample_ok: Optional[List[str]] = None
     ):
         super().__init__(func)
         trample_ok = trample_ok or []
@@ -25,7 +25,7 @@ def __init__(
             )
         )
 
-    def __set_name__(self, owner, name):
+    def __set_name__(self, owner: Any, name: str) -> None:
         super().__set_name__(owner, name)
         is_warn = is_err = False
         msg = ""
@@ -68,5 +68,5 @@ def __init__(self, *aliases: str, trample_ok: Optional[List[str]] = None):
         self._aliases = aliases
         self._trample_ok = trample_ok
 
-    def __call__(self, func):
+    def __call__(self, func: Any) -> valiased:
         return valiased(func, *self._aliases, trample_ok=self._trample_ok)