Expand typing to tests. (#387)

Author: Dreamsorcerer

.mypy.ini

@@ -0,0 +1,24 @@
+[mypy]
+files = aiohttp_jinja2, tests
+check_untyped_defs = True
+follow_imports_for_stubs = True
+disallow_any_decorated = True
+disallow_any_generics = True
+disallow_incomplete_defs = True
+disallow_subclassing_any = True
+disallow_untyped_calls = True
+disallow_untyped_decorators = True
+disallow_untyped_defs = True
+implicit_reexport = False
+no_implicit_optional = True
+show_error_codes = True
+strict_equality = True
+warn_incomplete_stub = True
+warn_redundant_casts = True
+warn_unreachable = True
+warn_unused_ignores = True
+disallow_any_unimported = True
+warn_return_any = True
+
+[mypy-tests.*]
+disallow_untyped_defs = False

aiohttp_jinja2/__init__.py

@@ -1,5 +1,6 @@
 import asyncio
 import functools
+import sys
 import warnings
 from typing import (
     Any,
@@ -9,7 +10,6 @@
     Iterable,
     Mapping,
     Optional,
-    Type,
     Union,
     cast,
     overload,
@@ -31,10 +31,6 @@
 APP_KEY = "aiohttp_jinja2_environment"
 REQUEST_CONTEXT_KEY = "aiohttp_jinja2_context"
 
-_SimpleHandler = Callable[[web.Request], Awaitable[web.StreamResponse]]
-_MethodHandler = Callable[[Any, web.Request], Awaitable[web.StreamResponse]]
-_ViewHandler = Callable[[Type[AbstractView]], Awaitable[web.StreamResponse]]
-_HandlerType = Union[_SimpleHandler, _MethodHandler, _ViewHandler]
 _TemplateReturnType = Awaitable[Union[web.StreamResponse, Mapping[str, Any]]]
 _SimpleTemplateHandler = Callable[[web.Request], _TemplateReturnType]
 _MethodTemplateHandler = Callable[[Any, web.Request], _TemplateReturnType]
@@ -43,12 +39,36 @@
     _SimpleTemplateHandler, _MethodTemplateHandler, _ViewTemplateHandler
 ]
 
+_ContextProcessor = Callable[[web.Request], Awaitable[Dict[str, Any]]]
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+
+    class _TemplateWrapped(Protocol):
+        @overload
+        async def __call__(self, request: web.Request) -> web.StreamResponse:
+            ...
+
+        @overload
+        async def __call__(self, view: AbstractView) -> web.StreamResponse:
+            ...
+
+        @overload
+        async def __call__(
+            self, _self: Any, request: web.Request
+        ) -> web.StreamResponse:
+            ...
+
+
+else:
+    _TemplateWrapped = Callable[..., web.StreamResponse]
+
 
 def setup(
     app: web.Application,
     *args: Any,
     app_key: str = APP_KEY,
-    context_processors: Iterable[Callable[[web.Request], Dict[str, Any]]] = (),
+    context_processors: Iterable[_ContextProcessor] = (),
     filters: Optional[Filters] = None,
     default_helpers: bool = True,
     **kwargs: Any,
@@ -109,7 +129,7 @@ def render_string(
 def render_template(
     template_name: str,
     request: web.Request,
-    context: Mapping[str, Any],
+    context: Optional[Mapping[str, Any]],
     *,
     app_key: str = APP_KEY,
     encoding: str = "utf-8",
@@ -131,8 +151,8 @@ def template(
     app_key: str = APP_KEY,
     encoding: str = "utf-8",
     status: int = 200,
-) -> Callable[[_TemplateHandler], _HandlerType]:
-    def wrapper(func: _TemplateHandler) -> _HandlerType:
+) -> Callable[[_TemplateHandler], _TemplateWrapped]:
+    def wrapper(func: _TemplateHandler) -> _TemplateWrapped:
         @overload
         async def wrapped(request: web.Request) -> web.StreamResponse:
             ...
@@ -151,7 +171,7 @@ async def wrapped(*args: Any) -> web.StreamResponse:
                 coro = func
             else:
                 warnings.warn(
-                    "Bare functions are deprecated, " "use async ones",
+                    "Bare functions are deprecated, use async ones",
                     DeprecationWarning,
                 )
                 coro = asyncio.coroutine(func)

aiohttp_jinja2/helpers.py

@@ -2,27 +2,40 @@
 useful context functions, see
 http://jinja.pocoo.org/docs/dev/api/#jinja2.contextfunction
 """
-from typing import Any, Dict, cast
+import sys
+from typing import Any, Dict, Optional, Union
 
 import jinja2
 from aiohttp import web
 from yarl import URL
 
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+
+    class _Context(TypedDict, total=False):
+        app: web.Application
+
+
+else:
+    _Context = Dict[str, Any]
+
 
 @jinja2.contextfunction
-def url_for(context: Dict[str, Any], __route_name: str, **parts: Any) -> URL:
+def url_for(
+    context: _Context,
+    __route_name: str,
+    query_: Optional[Dict[str, str]] = None,
+    **parts: Union[str, int]
+) -> URL:
     """Filter for generating urls.
 
     Usage: {{ url('the-view-name') }} might become "/path/to/view" or
     {{ url('item-details', id=123, query={'active': 'true'}) }}
     might become "/items/1?active=true".
     """
-    app = cast(web.Application, context["app"])
-
-    query = None
-    if "query_" in parts:
-        query = parts.pop("query_")
+    app = context["app"]
 
+    parts_clean: Dict[str, str] = {}
     for key in parts:
         val = parts[key]
         if isinstance(val, str):
@@ -37,16 +50,16 @@ def url_for(context: Dict[str, Any], __route_name: str, **parts: Any) -> URL:
                 "argument value should be str or int, "
                 "got {} -> [{}] {!r}".format(key, type(val), val)
             )
-        parts[key] = val
+        parts_clean[key] = val
 
-    url = app.router[__route_name].url_for(**parts)
-    if query:
-        url = url.with_query(query)
+    url = app.router[__route_name].url_for(**parts_clean)
+    if query_:
+        url = url.with_query(query_)
     return url
 
 
 @jinja2.contextfunction
-def static_url(context: Dict[str, Any], static_file_path: str) -> str:
+def static_url(context: _Context, static_file_path: str) -> str:
     """Filter for generating urls for static files.
 
     NOTE: you'll need

tests/__init__.py

@@ -1,3 +1,5 @@
+from typing import Dict, Union
+
 import jinja2
 from aiohttp import web
 
@@ -17,7 +19,7 @@ async def func(request):
         ),
     )
 
-    async def processor(request):
+    async def processor(request: web.Request) -> Dict[str, Union[str, int]]:
         return {"foo": 1, "bar": "should be overwriten"}
 
     app["aiohttp_jinja2_context_processors"] = (

tests/test_context_processors.py

@@ -1,14 +1,18 @@
+from typing import Awaitable, Callable, Dict, TypeVar
+
 import jinja2
 import pytest
 from aiohttp import web
 from aiohttp.test_utils import make_mocked_request
 
 import aiohttp_jinja2
 
+_T = TypeVar("_T")
+
 
 async def test_func(aiohttp_client):
     @aiohttp_jinja2.template("tmpl.jinja2")
-    async def func(request):
+    async def func(request: web.Request) -> Dict[str, str]:
         return {"head": "HEAD", "text": "text"}
 
     template = "<html><body><h1>{{head}}</h1>{{text}}</body></html>"
@@ -28,7 +32,7 @@ async def func(request):
 async def test_render_class_based_view(aiohttp_client):
     class MyView(web.View):
         @aiohttp_jinja2.template("tmpl.jinja2")
-        async def get(self):
+        async def get(self) -> Dict[str, str]:
             return {"head": "HEAD", "text": "text"}
 
     template = "<html><body><h1>{{head}}</h1>{{text}}</body></html>"
@@ -92,7 +96,7 @@ async def func(request):
 
 
 async def test_render_not_initialized():
-    async def func(request):
+    async def func(request: web.Request) -> web.Response:
         return aiohttp_jinja2.render_template("template", request, {})
 
     app = web.Application()
@@ -178,7 +182,7 @@ async def func(request):
 
 
 async def test_template_not_found():
-    async def func(request):
+    async def func(request: web.Request) -> web.Response:
         return aiohttp_jinja2.render_template("template", request, {})
 
     app = web.Application()
@@ -277,18 +281,20 @@ async def func(request):
 
 
 async def test_render_bare_funcs_deprecated(aiohttp_client):
-    def wrapper(func):
-        async def wrapped(request):
+    def wrapper(
+        func: Callable[[web.Request], Awaitable[_T]]
+    ) -> Callable[[web.Request], Awaitable[_T]]:
+        async def wrapped(request: web.Request) -> _T:
             with pytest.warns(
                 DeprecationWarning, match="Bare functions are deprecated"
             ):
                 return await func(request)
 
         return wrapped
 
-    @wrapper
+    @wrapper  # type: ignore[arg-type]  # Deprecated functionality
     @aiohttp_jinja2.template("tmpl.jinja2")
-    def func(request):
+    def func(request: web.Request) -> Dict[str, str]:
         return {"text": "OK"}
 
     app = web.Application()