Improved wrapper code so that the API is more consistent on failure

diff --git a/jinja2/asyncsupport.py b/jinja2/asyncsupport.py
index 0c4fecf6a4af3d5f60706afa147a260bea795652..72bbc510bd7966639318cf07d9e3f73d81d432ff 100644 (file)
--- a/jinja2/asyncsupport.py
+++ b/jinja2/asyncsupport.py
@@ -1,6 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+    jinja2.asyncsupport
+    ~~~~~~~~~~~~~~~~~~~
+
+    Has all the code for async support which is implemented as a patch
+    for supported Python versions.
+
+    :copyright: (c) 2017 by the Jinja Team.
+    :license: BSD, see LICENSE for more details.
+"""
 import sys
 import asyncio
 import inspect
+from functools import update_wrapper
 
 from jinja2.utils import concat, internalcode, concat, Markup
 from jinja2.environment import TemplateModule
@@ -40,7 +52,7 @@ def wrap_generate_func(original_generate):
         if not self.environment._async:
             return original_generate(self, *args, **kwargs)
         return _convert_generator(self, asyncio.get_event_loop(), args, kwargs)
-    return generate
+    return update_wrapper(generate, original_generate)
 
 
 async def render_async(self, *args, **kwargs):
@@ -64,7 +76,7 @@ def wrap_render_func(original_render):
             return original_render(self, *args, **kwargs)
         loop = asyncio.get_event_loop()
         return loop.run_until_complete(self.render_async(*args, **kwargs))
-    return render
+    return update_wrapper(render, original_render)
 
 
 def wrap_block_reference_call(original_call):
@@ -81,7 +93,7 @@ def wrap_block_reference_call(original_call):
             return original_call(self)
         return async_call(self)
 
-    return __call__
+    return update_wrapper(__call__, original_call)
 
 
 @internalcode
@@ -112,14 +124,17 @@ async def make_module_async(self, vars=None, shared=False, locals=None):
 
 def patch_template():
     from jinja2 import Template
-    Template.generate_async = generate_async
     Template.generate = wrap_generate_func(Template.generate)
-    Template.render_async = render_async
+    Template.generate_async = update_wrapper(
+        generate_async, Template.generate_async)
+    Template.render_async = update_wrapper(
+        render_async, Template.render_async)
     Template.render = wrap_render_func(Template.render)
     Template._get_default_module = wrap_default_module(
         Template._get_default_module)
     Template._get_default_module_async = get_default_module_async
-    Template.make_module_async = make_module_async
+    Template.make_module_async = update_wrapper(
+        make_module_async, Template.make_module_async)
 
 
 def patch_runtime():

diff --git a/jinja2/environment.py b/jinja2/environment.py
index f91b01dcc83415ca1e6dc42383e3e59d57a8c6b5..efbed6a4a0af0f4bd3c313c1b9e0504093b755df 100644 (file)
--- a/jinja2/environment.py
+++ b/jinja2/environment.py
@@ -991,6 +991,11 @@ class Template(object):
             exc_info = sys.exc_info()
         return self.environment.handle_exception(exc_info, True)
 
+    def render_async(self, *args, **kwargs):
+        # see asyncsupport for the actual implementation
+        raise NotImplementedError('This feature is not available for this '
+                                  'version of Python')
+
     def stream(self, *args, **kwargs):
         """Works exactly like :meth:`generate` but returns a
         :class:`TemplateStream`.
@@ -1015,6 +1020,11 @@ class Template(object):
             return
         yield self.environment.handle_exception(exc_info, True)
 
+    def generate_async(self, *args, **kwargs):
+        # see asyncsupport for the actual implementation
+        raise NotImplementedError('This feature is not available for this '
+                                  'version of Python')
+
     def new_context(self, vars=None, shared=False, locals=None):
         """Create a new :class:`Context` for this template.  The vars
         provided will be passed to the template.  Per default the globals
@@ -1035,6 +1045,11 @@ class Template(object):
         """
         return TemplateModule(self, self.new_context(vars, shared, locals))
 
+    def make_module_async(self, vars=None, shared=False, locals=None):
+        # see asyncsupport for the actual implementation
+        raise NotImplementedError('This feature is not available for this '
+                                  'version of Python')
+
     @internalcode
     def _get_default_module(self):
         if self._module is not None: