Test updates

Author: kutoga

.gitignore

@@ -36,5 +36,6 @@ nosetests.xml
 .pydevproject
 
 .venv
+.mypy_cache
 dist
 

.travis.yml

@@ -8,7 +8,7 @@ install:
 script:
   - python -mpytest ./tests
   - python -mpylint ./lazy_load
-  - python -mmypy ./lazy_load --ignore-missing-imports
+  - python -mmypy ./lazy_load --ignore-missing-imports --disallow-untyped-defs
   - find ./tests -name '*.py' | xargs python -mpylint --disable=missing-docstring,invalid-name,protected-access
-  - find ./tests -name '*.py' | xargs python -mmypy --ignore-missing-imports
+  - find ./tests -name '*.py' | xargs python -mmypy --ignore-missing-imports --disallow-untyped-defs
 

lazy_load/_lazy_load.py

@@ -9,38 +9,37 @@
 
 from lazy_object_proxy import Proxy as _LazyProxy
 
-_T1 = TypeVar('_T1')
-_T2 = TypeVar('_T2')
+_T = TypeVar('_T')
 
 _LAZY_FUNC_ORIGINAL_FUNC_ATTRIBUTE = '__wrapped_non_lazy_function__'
 
 def _is_lazy_object(obj: Any) -> bool:
     return obj is not None and isinstance(obj, _LazyProxy)
 
 @overload
-def lazy(target: Callable[..., _T1], *args: str, **kwargs: str) -> _T1: pass        # pylint: disable=missing-docstring,multiple-statements,unused-argument
+def lazy(target: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: pass          # pylint: disable=missing-docstring,multiple-statements,unused-argument
 @overload
-def lazy(target: _T1) -> _T1: pass                                                  # pylint: disable=missing-docstring,multiple-statements,unused-argument,function-redefined
+def lazy(target: _T) -> _T: pass                                                    # pylint: disable=missing-docstring,multiple-statements,unused-argument,function-redefined
 
 
-def lazy(target: Union[_T1, Callable[..., _T1]], *args: Any, **kwargs: Any) -> _T1: # pylint: disable=function-redefined
+def lazy(target: Union[_T, Callable[..., _T]], *args: Any, **kwargs: Any) -> _T:    # pylint: disable=function-redefined
     """
     Create a lazy loading object given a callable object and optional arguments.
     The created object will be generated by evaluating the given function
     as soon as it is used.
 
     Arguments:
-        target {Callable[..., _T1]} -- [The function to create the lazy loading object]
+        target {Callable[..., _T]} -- [The function to create the lazy loading object]
 
     Returns:
         _T -- [A proxy object for the lazy loading object.]
     """
     if not callable(target):
         raise ValueError('Invalid target.')
     if args or kwargs or not _is_lazy_object(target):
-        lazy_object = cast(_T1, _LazyProxy(lambda: target(*args, **kwargs)))
+        lazy_object = cast(_T, _LazyProxy(lambda: target(*args, **kwargs)))
     else:
-        lazy_object = cast(_T1, target)
+        lazy_object = cast(_T, target)
     return lazy_object
 
 lz: Callable = lazy
@@ -52,7 +51,7 @@ def _is_lazy_function(func: Callable) -> bool:
     return callable(func) and hasattr(func, _LAZY_FUNC_ORIGINAL_FUNC_ATTRIBUTE)
 
 class _LazyFunc:
-    def __call__(self, original_function: Callable[[_T1], _T2]) -> Callable[[_T1], _T2]:
+    def __call__(self, original_function: Callable[..., _T]) -> Callable[..., _T]:
         """
         Wrap a given function in a way that all its evaluations are lazy. This means
         a function call to the returned function will only result in an actual function
@@ -62,15 +61,15 @@ def __call__(self, original_function: Callable[[_T1], _T2]) -> Callable[[_T1], _
         The lazy evaluation works especially great for pure functions.
 
         Arguments:
-            original_function {Callable[[_T1], _T2]} -- [The function which should be wrapped.]
+            original_function {Callable[..., _T]} -- [The function which should be wrapped.]
 
         Returns:
-            Callable[[_T1], _T2] -- [The lazy evaluated version of the given function]
+            _T -- [The lazy evaluated version of the given function]
         """
         if _is_lazy_function(original_function):
             return original_function
         @wraps(original_function)
-        def _lazy_function(*args, **kwargs):
+        def _lazy_function(*args: Any, **kwargs: Any) -> _T:
             return lazy(lambda: original_function(*args, **kwargs))
         setattr(_lazy_function, _LAZY_FUNC_ORIGINAL_FUNC_ATTRIBUTE, original_function)
         return _lazy_function
@@ -138,7 +137,7 @@ def lazy_class(cls: Type) -> Type:
 An alias for lazy_class.
 """
 
-def force_eval(obj: _T1) -> _T1:
+def force_eval(obj: _T) -> _T:
     """
     Force the evaluation of a lazy object (Proxy). If a lazy function is given, the
     wrapped non-lazy version of the function is returned.
@@ -155,7 +154,7 @@ def force_eval(obj: _T1) -> _T1:
         return getattr(obj, _LAZY_FUNC_ORIGINAL_FUNC_ATTRIBUTE)
     return obj
 
-fe: Callable[[_T1], _T1] = force_eval
+fe: Callable[[_T], _T] = force_eval
 """
 An alias for force_eval.
 """

tests/test_sample.py

@@ -1,8 +1,7 @@
 from lazy_object_proxy import Proxy
 from lazy_load import lazy, lz, lazy_func, lf, ℒ, lazy_class, lc, force_eval, fe
 
-
-def test_aliases():
+def test_aliases() -> None:
     assert lazy is lz
 
     assert lazy_func is lf
@@ -12,9 +11,9 @@ def test_aliases():
 
     assert force_eval is fe
 
-def test_lazy_simple_expression_evaluation():
+def test_lazy_simple_expression_evaluation() -> None:
     evaluated = False
-    def add(x, y):
+    def add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -26,9 +25,9 @@ def add(x, y):
     assert evaluated
     assert isinstance(res, int)
 
-def test_lazy_function_with_eagle_argument_evaluation():
+def test_lazy_function_with_eagle_argument_evaluation() -> None:
     evaluated = False
-    def add(x, y):
+    def add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -40,9 +39,9 @@ def add(x, y):
     assert evaluated
     assert isinstance(res, int)
 
-def test_lazy_function_evaluation():
+def test_lazy_function_evaluation() -> None:
     evaluated = False
-    def add(x, y):
+    def add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -55,11 +54,11 @@ def add(x, y):
     assert evaluated
     assert isinstance(res, int)
 
-def test_lazy_function_decorator():
+def test_lazy_function_decorator() -> None:
     evaluated = False
 
     @lazy_func
-    def lazy_add(x, y):
+    def lazy_add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -71,34 +70,34 @@ def lazy_add(x, y):
     assert evaluated
     assert isinstance(res, int)
 
-def test_lazy_class():
+def test_lazy_class() -> None:
     evaluated = False
 
     @lazy_class
     class LazyClass:
-        def __init__(self, n):
+        def __init__(self, n: int):
             self._n = n
 
-        def add(self, m) -> int:
+        def add(self, m: int) -> int:
             nonlocal evaluated
             evaluated = True
             return self._n + m
 
-        def sub(self, m) -> None:
+        def sub(self, m: int) -> None:
             # Return type is None: This function should not be lazy evaluated
             nonlocal evaluated
             evaluated = True
-            return self._n - m
+            return self._n - m  # type: ignore
 
         @lazy_func
-        def mul(self, m) -> None:
+        def mul(self, m: int) -> None:
             # Return type is None: This function should not be lazy evaluated;
             # BUT there is the decorater: it makes the function lazy
             nonlocal evaluated
             evaluated = True
-            return self._n * m
+            return self._n * m  # type: ignore
 
-        def _div(self, m) -> int:
+        def _div(self, m: int) -> int:
             # Non-public functions are never made lazy by lazy_class
             nonlocal evaluated
             evaluated = True
@@ -114,13 +113,13 @@ def _div(self, m) -> int:
     assert isinstance(res, int)
 
     evaluated = False
-    res = lazy_obj.sub(2)
+    res = lazy_obj.sub(2)   # type: ignore
     assert not isinstance(res, Proxy)
     assert evaluated
     assert res == -1
 
     evaluated = False
-    res = lazy_obj.mul(2)
+    res = lazy_obj.mul(2)   # type: ignore
     assert not evaluated
     assert isinstance(res, Proxy)
     assert res == 2
@@ -133,9 +132,9 @@ def _div(self, m) -> int:
     assert evaluated
     assert res == 1
 
-def test_force_eval_on_objects():
+def test_force_eval_on_objects() -> None:
     evaluated = False
-    def do_something(x, y):
+    def do_something(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -145,19 +144,19 @@ def do_something(x, y):
     force_eval(res)
     assert evaluated
 
-def test_force_eval_on_callables():
+def test_force_eval_on_callables() -> None:
     evaluated = False
-    def do_something():
+    def do_something() -> None:
         nonlocal evaluated
         evaluated = True
     do_something_lazy = ℒ[do_something]
     assert do_something_lazy is not do_something
     assert fe(do_something_lazy) is do_something
     assert not evaluated
 
-def test_multiple_lazy_on_expression():
+def test_multiple_lazy_on_expression() -> None:
     evaluated = False
-    def add(x, y):
+    def add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y
@@ -178,9 +177,9 @@ def add(x, y):
     assert res == 3
     assert evaluated
 
-def test_multiple_lazy_onfunction():
+def test_multiple_lazy_onfunction() -> None:
     evaluated = False
-    def add(x, y):
+    def add(x: int, y: int) -> int:
         nonlocal evaluated
         evaluated = True
         return x + y