From: Armin Ronacher <armin.ronacher@active-4.com>
Date: Wed, 28 Dec 2016 19:31:14 +0000 (+0100)
Subject: Improved wrapper code so that the API is more consistent on failure
X-Git-Tag: 2.9~62
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=efa5d3161d4c5b896e870901c6a0a0a16c602950;p=thirdparty%2Fjinja.git

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

diff --git a/jinja2/asyncsupport.py b/jinja2/asyncsupport.py
index 0c4fecf6..72bbc510 100644
--- 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 f91b01dc..efbed6a4 100644
--- 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: