Restoring authorship annotation for <floatdrop@yandex-team.ru>. Commit 2 of 2.

24 files changed, 2869 insertions, 2869 deletions

diff --git a/contrib/python/Jinja2/py2/tests/conftest.py b/contrib/python/Jinja2/py2/tests/conftest.py
index f900cd780a..c34e6c53c6 100644
--- a/contrib/python/Jinja2/py2/tests/conftest.py
+++ b/contrib/python/Jinja2/py2/tests/conftest.py
@@ -1,39 +1,39 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import os
- 
-import pytest 
- 
+
+import pytest
+
 from jinja2 import Environment
-from jinja2 import loaders 
-from jinja2.utils import have_async_gen 
- 
- 
+from jinja2 import loaders
+from jinja2.utils import have_async_gen
+
+
 def pytest_ignore_collect(path):
     if "async" in path.basename and not have_async_gen:
-        return True 
-    return False 
- 
- 
-@pytest.fixture 
-def env(): 
+        return True
+    return False
+
+
+@pytest.fixture
+def env():
     """returns a new environment."""
-    return Environment() 
- 
- 
-@pytest.fixture 
-def dict_loader(): 
+    return Environment()
+
+
+@pytest.fixture
+def dict_loader():
     """returns DictLoader"""
     return loaders.DictLoader({"justdict.html": "FOO"})
- 
- 
-@pytest.fixture 
-def package_loader(): 
+
+
+@pytest.fixture
+def package_loader():
     """returns PackageLoader initialized from templates"""
     return loaders.PackageLoader("res", "templates")
- 
- 
-@pytest.fixture 
-def filesystem_loader(): 
+
+
+@pytest.fixture
+def filesystem_loader():
     """returns FileSystemLoader initialized to res/templates directory"""
     try:
         import yatest.common
@@ -41,21 +41,21 @@ def filesystem_loader():
     except ImportError:
         here = os.path.dirname(os.path.abspath(__file__))
     return loaders.FileSystemLoader(here + "/res/templates")
- 
- 
-@pytest.fixture 
-def function_loader(): 
+
+
+@pytest.fixture
+def function_loader():
     """returns a FunctionLoader"""
     return loaders.FunctionLoader({"justfunction.html": "FOO"}.get)
- 
- 
-@pytest.fixture 
-def choice_loader(dict_loader, package_loader): 
+
+
+@pytest.fixture
+def choice_loader(dict_loader, package_loader):
     """returns a ChoiceLoader"""
-    return loaders.ChoiceLoader([dict_loader, package_loader]) 
- 
- 
-@pytest.fixture 
-def prefix_loader(filesystem_loader, dict_loader): 
+    return loaders.ChoiceLoader([dict_loader, package_loader])
+
+
+@pytest.fixture
+def prefix_loader(filesystem_loader, dict_loader):
     """returns a PrefixLoader"""
     return loaders.PrefixLoader({"a": filesystem_loader, "b": dict_loader})
diff --git a/contrib/python/Jinja2/py2/tests/res/templates/broken.html b/contrib/python/Jinja2/py2/tests/res/templates/broken.html
index b38d7bb927..77669fae57 100644
--- a/contrib/python/Jinja2/py2/tests/res/templates/broken.html
+++ b/contrib/python/Jinja2/py2/tests/res/templates/broken.html
@@ -1,3 +1,3 @@
-Before 
-{{ fail() }} 
-After 
+Before
+{{ fail() }}
+After
diff --git a/contrib/python/Jinja2/py2/tests/res/templates/foo/test.html b/contrib/python/Jinja2/py2/tests/res/templates/foo/test.html
index bbd2d23cd1..b7d6715e2d 100644
--- a/contrib/python/Jinja2/py2/tests/res/templates/foo/test.html
+++ b/contrib/python/Jinja2/py2/tests/res/templates/foo/test.html
@@ -1 +1 @@
-FOO 
+FOO
diff --git a/contrib/python/Jinja2/py2/tests/res/templates/syntaxerror.html b/contrib/python/Jinja2/py2/tests/res/templates/syntaxerror.html
index dc8c8af224..f21b817939 100644
--- a/contrib/python/Jinja2/py2/tests/res/templates/syntaxerror.html
+++ b/contrib/python/Jinja2/py2/tests/res/templates/syntaxerror.html
@@ -1,4 +1,4 @@
-Foo 
-{% for item in broken %} 
-  ... 
-{% endif %} 
+Foo
+{% for item in broken %}
+  ...
+{% endif %}
diff --git a/contrib/python/Jinja2/py2/tests/res/templates/test.html b/contrib/python/Jinja2/py2/tests/res/templates/test.html
index 640acfc455..ba578e48b1 100644
--- a/contrib/python/Jinja2/py2/tests/res/templates/test.html
+++ b/contrib/python/Jinja2/py2/tests/res/templates/test.html
@@ -1 +1 @@
-BAR 
+BAR
diff --git a/contrib/python/Jinja2/py2/tests/test_api.py b/contrib/python/Jinja2/py2/tests/test_api.py
index 0ac95186bd..7a1cae866b 100644
--- a/contrib/python/Jinja2/py2/tests/test_api.py
+++ b/contrib/python/Jinja2/py2/tests/test_api.py
@@ -1,9 +1,9 @@
-# -*- coding: utf-8 -*- 
-import os 
+# -*- coding: utf-8 -*-
+import os
 import shutil
-import tempfile 
- 
-import pytest 
+import tempfile
+
+import pytest
 
 from jinja2 import ChainableUndefined
 from jinja2 import DebugUndefined
@@ -17,32 +17,32 @@ from jinja2 import Template
 from jinja2 import TemplatesNotFound
 from jinja2 import Undefined
 from jinja2 import UndefinedError
-from jinja2.compiler import CodeGenerator 
-from jinja2.runtime import Context 
+from jinja2.compiler import CodeGenerator
+from jinja2.runtime import Context
 from jinja2.utils import contextfunction
-from jinja2.utils import Cycler 
+from jinja2.utils import Cycler
 from jinja2.utils import environmentfunction
 from jinja2.utils import evalcontextfunction
- 
- 
-class TestExtendedAPI(object): 
-    def test_item_and_attribute(self, env): 
-        from jinja2.sandbox import SandboxedEnvironment 
- 
-        for env in Environment(), SandboxedEnvironment(): 
-            # the |list is necessary for python3 
+
+
+class TestExtendedAPI(object):
+    def test_item_and_attribute(self, env):
+        from jinja2.sandbox import SandboxedEnvironment
+
+        for env in Environment(), SandboxedEnvironment():
+            # the |list is necessary for python3
             tmpl = env.from_string("{{ foo.items()|list }}")
             assert tmpl.render(foo={"items": 42}) == "[('items', 42)]"
-            tmpl = env.from_string('{{ foo|attr("items")()|list }}') 
+            tmpl = env.from_string('{{ foo|attr("items")()|list }}')
             assert tmpl.render(foo={"items": 42}) == "[('items', 42)]"
-            tmpl = env.from_string('{{ foo["items"] }}') 
+            tmpl = env.from_string('{{ foo["items"] }}')
             assert tmpl.render(foo={"items": 42}) == "42"
- 
+
     def test_finalize(self):
         e = Environment(finalize=lambda v: "" if v is None else v)
         t = e.from_string("{% for item in seq %}|{{ item }}{% endfor %}")
         assert t.render(seq=(None, 1, "foo")) == "||1|foo"
- 
+
     def test_finalize_constant_expression(self):
         e = Environment(finalize=lambda v: "" if v is None else v)
         t = e.from_string("<{{ none }}>")
@@ -83,34 +83,34 @@ class TestExtendedAPI(object):
         t = e.from_string("{{ value }}")
         assert t.render(value="hello") == "{{ 'hello' }}"
 
-    def test_cycler(self, env): 
-        items = 1, 2, 3 
-        c = Cycler(*items) 
-        for item in items + items: 
-            assert c.current == item 
-            assert next(c) == item 
-        next(c) 
-        assert c.current == 2 
-        c.reset() 
-        assert c.current == 1 
- 
-    def test_expressions(self, env): 
-        expr = env.compile_expression("foo") 
-        assert expr() is None 
-        assert expr(foo=42) == 42 
-        expr2 = env.compile_expression("foo", undefined_to_none=False) 
-        assert is_undefined(expr2()) 
- 
-        expr = env.compile_expression("42 + foo") 
-        assert expr(foo=42) == 84 
- 
-    def test_template_passthrough(self, env): 
+    def test_cycler(self, env):
+        items = 1, 2, 3
+        c = Cycler(*items)
+        for item in items + items:
+            assert c.current == item
+            assert next(c) == item
+        next(c)
+        assert c.current == 2
+        c.reset()
+        assert c.current == 1
+
+    def test_expressions(self, env):
+        expr = env.compile_expression("foo")
+        assert expr() is None
+        assert expr(foo=42) == 42
+        expr2 = env.compile_expression("foo", undefined_to_none=False)
+        assert is_undefined(expr2())
+
+        expr = env.compile_expression("42 + foo")
+        assert expr(foo=42) == 84
+
+    def test_template_passthrough(self, env):
         t = Template("Content")
-        assert env.get_template(t) is t 
-        assert env.select_template([t]) is t 
-        assert env.get_or_select_template([t]) is t 
-        assert env.get_or_select_template(t) is t 
- 
+        assert env.get_template(t) is t
+        assert env.select_template([t]) is t
+        assert env.get_or_select_template([t]) is t
+        assert env.get_or_select_template(t) is t
+
     def test_get_template_undefined(self, env):
         """Passing Undefined to get/select_template raises an
         UndefinedError or shows the undefined message in the list.
@@ -134,12 +134,12 @@ class TestExtendedAPI(object):
         assert "'no_name_1' is undefined" in exc_message
         assert "no_name_2" in exc_message
 
-    def test_autoescape_autoselect(self, env): 
-        def select_autoescape(name): 
+    def test_autoescape_autoselect(self, env):
+        def select_autoescape(name):
             if name is None or "." not in name:
-                return False 
+                return False
             return name.endswith(".html")
- 
+
         env = Environment(
             autoescape=select_autoescape,
             loader=DictLoader({"test.txt": "{{ foo }}", "test.html": "{{ foo }}"}),
@@ -150,7 +150,7 @@ class TestExtendedAPI(object):
         assert t.render(foo="<foo>") == "&lt;foo&gt;"
         t = env.from_string("{{ foo }}")
         assert t.render(foo="<foo>") == "<foo>"
- 
+
     def test_sandbox_max_range(self, env):
         from jinja2.sandbox import SandboxedEnvironment, MAX_RANGE
 
@@ -161,61 +161,61 @@ class TestExtendedAPI(object):
             t.render(total=MAX_RANGE + 1)
 
 
-class TestMeta(object): 
-    def test_find_undeclared_variables(self, env): 
+class TestMeta(object):
+    def test_find_undeclared_variables(self, env):
         ast = env.parse("{% set foo = 42 %}{{ bar + foo }}")
-        x = meta.find_undeclared_variables(ast) 
+        x = meta.find_undeclared_variables(ast)
         assert x == set(["bar"])
- 
+
         ast = env.parse(
             "{% set foo = 42 %}{{ bar + foo }}"
             "{% macro meh(x) %}{{ x }}{% endmacro %}"
             "{% for item in seq %}{{ muh(item) + meh(seq) }}"
             "{% endfor %}"
         )
-        x = meta.find_undeclared_variables(ast) 
+        x = meta.find_undeclared_variables(ast)
         assert x == set(["bar", "seq", "muh"])
- 
+
         ast = env.parse("{% for x in range(5) %}{{ x }}{% endfor %}{{ foo }}")
         x = meta.find_undeclared_variables(ast)
         assert x == set(["foo"])
 
-    def test_find_refererenced_templates(self, env): 
-        ast = env.parse('{% extends "layout.html" %}{% include helper %}') 
-        i = meta.find_referenced_templates(ast) 
+    def test_find_refererenced_templates(self, env):
+        ast = env.parse('{% extends "layout.html" %}{% include helper %}')
+        i = meta.find_referenced_templates(ast)
         assert next(i) == "layout.html"
-        assert next(i) is None 
-        assert list(i) == [] 
- 
+        assert next(i) is None
+        assert list(i) == []
+
         ast = env.parse(
             '{% extends "layout.html" %}'
             '{% from "test.html" import a, b as c %}'
             '{% import "meh.html" as meh %}'
             '{% include "muh.html" %}'
         )
-        i = meta.find_referenced_templates(ast) 
+        i = meta.find_referenced_templates(ast)
         assert list(i) == ["layout.html", "test.html", "meh.html", "muh.html"]
- 
-    def test_find_included_templates(self, env): 
-        ast = env.parse('{% include ["foo.html", "bar.html"] %}') 
-        i = meta.find_referenced_templates(ast) 
+
+    def test_find_included_templates(self, env):
+        ast = env.parse('{% include ["foo.html", "bar.html"] %}')
+        i = meta.find_referenced_templates(ast)
         assert list(i) == ["foo.html", "bar.html"]
- 
-        ast = env.parse('{% include ("foo.html", "bar.html") %}') 
-        i = meta.find_referenced_templates(ast) 
+
+        ast = env.parse('{% include ("foo.html", "bar.html") %}')
+        i = meta.find_referenced_templates(ast)
         assert list(i) == ["foo.html", "bar.html"]
- 
-        ast = env.parse('{% include ["foo.html", "bar.html", foo] %}') 
-        i = meta.find_referenced_templates(ast) 
+
+        ast = env.parse('{% include ["foo.html", "bar.html", foo] %}')
+        i = meta.find_referenced_templates(ast)
         assert list(i) == ["foo.html", "bar.html", None]
- 
-        ast = env.parse('{% include ("foo.html", "bar.html", foo) %}') 
-        i = meta.find_referenced_templates(ast) 
+
+        ast = env.parse('{% include ("foo.html", "bar.html", foo) %}')
+        i = meta.find_referenced_templates(ast)
         assert list(i) == ["foo.html", "bar.html", None]
- 
- 
-class TestStreaming(object): 
-    def test_basic_streaming(self, env): 
+
+
+class TestStreaming(object):
+    def test_basic_streaming(self, env):
         t = env.from_string(
             "<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>"
             "{%- endfor %}</ul>"
@@ -223,52 +223,52 @@ class TestStreaming(object):
         stream = t.stream(seq=list(range(3)))
         assert next(stream) == "<ul>"
         assert "".join(stream) == "<li>1 - 0</li><li>2 - 1</li><li>3 - 2</li></ul>"
- 
-    def test_buffered_streaming(self, env): 
+
+    def test_buffered_streaming(self, env):
         tmpl = env.from_string(
             "<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>"
             "{%- endfor %}</ul>"
         )
         stream = tmpl.stream(seq=list(range(3)))
-        stream.enable_buffering(size=3) 
+        stream.enable_buffering(size=3)
         assert next(stream) == u"<ul><li>1"
         assert next(stream) == u" - 0</li>"
- 
-    def test_streaming_behavior(self, env): 
-        tmpl = env.from_string("") 
-        stream = tmpl.stream() 
-        assert not stream.buffered 
-        stream.enable_buffering(20) 
-        assert stream.buffered 
-        stream.disable_buffering() 
-        assert not stream.buffered 
- 
-    def test_dump_stream(self, env): 
-        tmp = tempfile.mkdtemp() 
-        try: 
-            tmpl = env.from_string(u"\u2713") 
-            stream = tmpl.stream() 
+
+    def test_streaming_behavior(self, env):
+        tmpl = env.from_string("")
+        stream = tmpl.stream()
+        assert not stream.buffered
+        stream.enable_buffering(20)
+        assert stream.buffered
+        stream.disable_buffering()
+        assert not stream.buffered
+
+    def test_dump_stream(self, env):
+        tmp = tempfile.mkdtemp()
+        try:
+            tmpl = env.from_string(u"\u2713")
+            stream = tmpl.stream()
             stream.dump(os.path.join(tmp, "dump.txt"), "utf-8")
             with open(os.path.join(tmp, "dump.txt"), "rb") as f:
                 assert f.read() == b"\xe2\x9c\x93"
-        finally: 
-            shutil.rmtree(tmp) 
- 
- 
-class TestUndefined(object): 
-    def test_stopiteration_is_undefined(self): 
-        def test(): 
-            raise StopIteration() 
+        finally:
+            shutil.rmtree(tmp)
+
+
+class TestUndefined(object):
+    def test_stopiteration_is_undefined(self):
+        def test():
+            raise StopIteration()
 
         t = Template("A{{ test() }}B")
         assert t.render(test=test) == "AB"
         t = Template("A{{ test().missingattribute }}B")
-        pytest.raises(UndefinedError, t.render, test=test) 
- 
-    def test_undefined_and_special_attributes(self): 
+        pytest.raises(UndefinedError, t.render, test=test)
+
+    def test_undefined_and_special_attributes(self):
         with pytest.raises(AttributeError):
             Undefined("Foo").__dict__
- 
+
     def test_undefined_attribute_error(self):
         # Django's LazyObject turns the __class__ attribute into a
         # property that resolves the wrapped function. If that wrapped
@@ -284,34 +284,34 @@ class TestUndefined(object):
         with pytest.raises(UndefinedError):
             getattr(u, "recursion", None)
 
-    def test_logging_undefined(self): 
-        _messages = [] 
- 
-        class DebugLogger(object): 
-            def warning(self, msg, *args): 
+    def test_logging_undefined(self):
+        _messages = []
+
+        class DebugLogger(object):
+            def warning(self, msg, *args):
                 _messages.append("W:" + msg % args)
- 
-            def error(self, msg, *args): 
+
+            def error(self, msg, *args):
                 _messages.append("E:" + msg % args)
- 
-        logging_undefined = make_logging_undefined(DebugLogger()) 
-        env = Environment(undefined=logging_undefined) 
+
+        logging_undefined = make_logging_undefined(DebugLogger())
+        env = Environment(undefined=logging_undefined)
         assert env.from_string("{{ missing }}").render() == u""
         pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
         assert env.from_string("{{ missing|list }}").render() == "[]"
         assert env.from_string("{{ missing is not defined }}").render() == "True"
         assert env.from_string("{{ foo.missing }}").render(foo=42) == ""
         assert env.from_string("{{ not missing }}").render() == "True"
-        assert _messages == [ 
+        assert _messages == [
             "W:Template variable warning: missing is undefined",
-            "E:Template variable error: 'missing' is undefined", 
+            "E:Template variable error: 'missing' is undefined",
             "W:Template variable warning: missing is undefined",
             "W:Template variable warning: int object has no attribute missing",
             "W:Template variable warning: missing is undefined",
-        ] 
- 
-    def test_default_undefined(self): 
-        env = Environment(undefined=Undefined) 
+        ]
+
+    def test_default_undefined(self):
+        env = Environment(undefined=Undefined)
         assert env.from_string("{{ missing }}").render() == u""
         pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
         assert env.from_string("{{ missing|list }}").render() == "[]"
@@ -326,7 +326,7 @@ class TestUndefined(object):
         assert hash(und1) == hash(und2) == hash(Undefined())
         with pytest.raises(AttributeError):
             getattr(Undefined, "__slots__")  # noqa: B009
- 
+
     def test_chainable_undefined(self):
         env = Environment(undefined=ChainableUndefined)
         # The following tests are copied from test_default_undefined
@@ -355,15 +355,15 @@ class TestUndefined(object):
             == u"baz"
         )
 
-    def test_debug_undefined(self): 
-        env = Environment(undefined=DebugUndefined) 
+    def test_debug_undefined(self):
+        env = Environment(undefined=DebugUndefined)
         assert env.from_string("{{ missing }}").render() == "{{ missing }}"
         pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
         assert env.from_string("{{ missing|list }}").render() == "[]"
         assert env.from_string("{{ missing is not defined }}").render() == "True"
         assert (
             env.from_string("{{ foo.missing }}").render(foo=42)
-            == u"{{ no such element: int object['missing'] }}" 
+            == u"{{ no such element: int object['missing'] }}"
         )
         assert env.from_string("{{ not missing }}").render() == "True"
         undefined_hint = "this is testing undefined hint of DebugUndefined"
@@ -373,9 +373,9 @@ class TestUndefined(object):
         )
         with pytest.raises(AttributeError):
             getattr(DebugUndefined, "__slots__")  # noqa: B009
- 
-    def test_strict_undefined(self): 
-        env = Environment(undefined=StrictUndefined) 
+
+    def test_strict_undefined(self):
+        env = Environment(undefined=StrictUndefined)
         pytest.raises(UndefinedError, env.from_string("{{ missing }}").render)
         pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
         pytest.raises(UndefinedError, env.from_string("{{ missing|list }}").render)
@@ -391,47 +391,47 @@ class TestUndefined(object):
         with pytest.raises(AttributeError):
             getattr(StrictUndefined, "__slots__")  # noqa: B009
         assert env.from_string('{{ "foo" if false }}').render() == ""
- 
-    def test_indexing_gives_undefined(self): 
-        t = Template("{{ var[42].foo }}") 
-        pytest.raises(UndefinedError, t.render, var=0) 
- 
-    def test_none_gives_proper_error(self): 
+
+    def test_indexing_gives_undefined(self):
+        t = Template("{{ var[42].foo }}")
+        pytest.raises(UndefinedError, t.render, var=0)
+
+    def test_none_gives_proper_error(self):
         with pytest.raises(UndefinedError, match="'None' has no attribute 'split'"):
             Environment().getattr(None, "split")()
- 
-    def test_object_repr(self): 
+
+    def test_object_repr(self):
         with pytest.raises(
             UndefinedError, match="'int object' has no attribute 'upper'"
         ):
             Undefined(obj=42, name="upper")()
- 
- 
-class TestLowLevel(object): 
-    def test_custom_code_generator(self): 
-        class CustomCodeGenerator(CodeGenerator): 
-            def visit_Const(self, node, frame=None): 
-                # This method is pure nonsense, but works fine for testing... 
+
+
+class TestLowLevel(object):
+    def test_custom_code_generator(self):
+        class CustomCodeGenerator(CodeGenerator):
+            def visit_Const(self, node, frame=None):
+                # This method is pure nonsense, but works fine for testing...
                 if node.value == "foo":
                     self.write(repr("bar"))
-                else: 
-                    super(CustomCodeGenerator, self).visit_Const(node, frame) 
- 
-        class CustomEnvironment(Environment): 
-            code_generator_class = CustomCodeGenerator 
- 
-        env = CustomEnvironment() 
-        tmpl = env.from_string('{% set foo = "foo" %}{{ foo }}') 
+                else:
+                    super(CustomCodeGenerator, self).visit_Const(node, frame)
+
+        class CustomEnvironment(Environment):
+            code_generator_class = CustomCodeGenerator
+
+        env = CustomEnvironment()
+        tmpl = env.from_string('{% set foo = "foo" %}{{ foo }}')
         assert tmpl.render() == "bar"
- 
-    def test_custom_context(self): 
-        class CustomContext(Context): 
-            def resolve_or_missing(self, key): 
+
+    def test_custom_context(self):
+        class CustomContext(Context):
+            def resolve_or_missing(self, key):
                 return "resolve-" + key
- 
-        class CustomEnvironment(Environment): 
-            context_class = CustomContext 
- 
-        env = CustomEnvironment() 
+
+        class CustomEnvironment(Environment):
+            context_class = CustomContext
+
+        env = CustomEnvironment()
         tmpl = env.from_string("{{ foo }}")
         assert tmpl.render() == "resolve-foo"
diff --git a/contrib/python/Jinja2/py2/tests/test_async.py b/contrib/python/Jinja2/py2/tests/test_async.py
index 6059c1272a..2b9974e35d 100644
--- a/contrib/python/Jinja2/py2/tests/test_async.py
+++ b/contrib/python/Jinja2/py2/tests/test_async.py
@@ -1,7 +1,7 @@
-import asyncio 
- 
+import asyncio
+
 import pytest
- 
+
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2 import Template
@@ -9,113 +9,113 @@ from jinja2.asyncsupport import auto_aiter
 from jinja2.exceptions import TemplateNotFound
 from jinja2.exceptions import TemplatesNotFound
 from jinja2.exceptions import UndefinedError
- 
-
-def run(coro): 
-    loop = asyncio.get_event_loop() 
-    return loop.run_until_complete(coro) 
- 
- 
-def test_basic_async(): 
+
+
+def run(coro):
+    loop = asyncio.get_event_loop()
+    return loop.run_until_complete(coro)
+
+
+def test_basic_async():
     t = Template(
         "{% for item in [1, 2, 3] %}[{{ item }}]{% endfor %}", enable_async=True
     )
 
-    async def func(): 
-        return await t.render_async() 
- 
-    rv = run(func()) 
+    async def func():
+        return await t.render_async()
+
+    rv = run(func())
     assert rv == "[1][2][3]"
- 
- 
-def test_await_on_calls(): 
+
+
+def test_await_on_calls():
     t = Template("{{ async_func() + normal_func() }}", enable_async=True)
- 
-    async def async_func(): 
-        return 42 
- 
-    def normal_func(): 
-        return 23 
- 
-    async def func(): 
+
+    async def async_func():
+        return 42
+
+    def normal_func():
+        return 23
+
+    async def func():
         return await t.render_async(async_func=async_func, normal_func=normal_func)
- 
-    rv = run(func()) 
+
+    rv = run(func())
     assert rv == "65"
- 
- 
-def test_await_on_calls_normal_render(): 
+
+
+def test_await_on_calls_normal_render():
     t = Template("{{ async_func() + normal_func() }}", enable_async=True)
- 
-    async def async_func(): 
-        return 42 
- 
-    def normal_func(): 
-        return 23 
- 
+
+    async def async_func():
+        return 42
+
+    def normal_func():
+        return 23
+
     rv = t.render(async_func=async_func, normal_func=normal_func)
- 
+
     assert rv == "65"
- 
- 
-def test_await_and_macros(): 
+
+
+def test_await_and_macros():
     t = Template(
         "{% macro foo(x) %}[{{ x }}][{{ async_func() }}]{% endmacro %}{{ foo(42) }}",
         enable_async=True,
     )
- 
-    async def async_func(): 
-        return 42 
- 
-    async def func(): 
-        return await t.render_async(async_func=async_func) 
- 
-    rv = run(func()) 
+
+    async def async_func():
+        return 42
+
+    async def func():
+        return await t.render_async(async_func=async_func)
+
+    rv = run(func())
     assert rv == "[42][42]"
- 
- 
-def test_async_blocks(): 
+
+
+def test_async_blocks():
     t = Template(
         "{% block foo %}<Test>{% endblock %}{{ self.foo() }}",
         enable_async=True,
         autoescape=True,
     )
 
-    async def func(): 
-        return await t.render_async() 
- 
-    rv = run(func()) 
+    async def func():
+        return await t.render_async()
+
+    rv = run(func())
     assert rv == "<Test><Test>"
- 
- 
-def test_async_generate(): 
+
+
+def test_async_generate():
     t = Template("{% for x in [1, 2, 3] %}{{ x }}{% endfor %}", enable_async=True)
-    rv = list(t.generate()) 
+    rv = list(t.generate())
     assert rv == ["1", "2", "3"]
- 
- 
-def test_async_iteration_in_templates(): 
+
+
+def test_async_iteration_in_templates():
     t = Template("{% for x in rng %}{{ x }}{% endfor %}", enable_async=True)
 
-    async def async_iterator(): 
-        for item in [1, 2, 3]: 
-            yield item 
+    async def async_iterator():
+        for item in [1, 2, 3]:
+            yield item
 
-    rv = list(t.generate(rng=async_iterator())) 
+    rv = list(t.generate(rng=async_iterator()))
     assert rv == ["1", "2", "3"]
- 
- 
-def test_async_iteration_in_templates_extended(): 
+
+
+def test_async_iteration_in_templates_extended():
     t = Template(
         "{% for x in rng %}{{ loop.index0 }}/{{ x }}{% endfor %}", enable_async=True
     )
     stream = t.generate(rng=auto_aiter(range(1, 4)))
     assert next(stream) == "0"
     assert "".join(stream) == "/11/22/3"
- 
- 
-@pytest.fixture 
-def test_env_async(): 
+
+
+@pytest.fixture
+def test_env_async():
     env = Environment(
         loader=DictLoader(
             dict(
@@ -127,93 +127,93 @@ def test_env_async():
         enable_async=True,
     )
     env.globals["bar"] = 23
-    return env 
- 
- 
-class TestAsyncImports(object): 
-    def test_context_imports(self, test_env_async): 
-        t = test_env_async.from_string('{% import "module" as m %}{{ m.test() }}') 
+    return env
+
+
+class TestAsyncImports(object):
+    def test_context_imports(self, test_env_async):
+        t = test_env_async.from_string('{% import "module" as m %}{{ m.test() }}')
         assert t.render(foo=42) == "[|23]"
-        t = test_env_async.from_string( 
-            '{% import "module" as m without context %}{{ m.test() }}' 
-        ) 
+        t = test_env_async.from_string(
+            '{% import "module" as m without context %}{{ m.test() }}'
+        )
         assert t.render(foo=42) == "[|23]"
-        t = test_env_async.from_string( 
-            '{% import "module" as m with context %}{{ m.test() }}' 
-        ) 
+        t = test_env_async.from_string(
+            '{% import "module" as m with context %}{{ m.test() }}'
+        )
         assert t.render(foo=42) == "[42|23]"
-        t = test_env_async.from_string('{% from "module" import test %}{{ test() }}') 
+        t = test_env_async.from_string('{% from "module" import test %}{{ test() }}')
         assert t.render(foo=42) == "[|23]"
-        t = test_env_async.from_string( 
-            '{% from "module" import test without context %}{{ test() }}' 
-        ) 
+        t = test_env_async.from_string(
+            '{% from "module" import test without context %}{{ test() }}'
+        )
         assert t.render(foo=42) == "[|23]"
-        t = test_env_async.from_string( 
-            '{% from "module" import test with context %}{{ test() }}' 
-        ) 
+        t = test_env_async.from_string(
+            '{% from "module" import test with context %}{{ test() }}'
+        )
         assert t.render(foo=42) == "[42|23]"
- 
-    def test_trailing_comma(self, test_env_async): 
-        test_env_async.from_string('{% from "foo" import bar, baz with context %}') 
-        test_env_async.from_string('{% from "foo" import bar, baz, with context %}') 
-        test_env_async.from_string('{% from "foo" import bar, with context %}') 
-        test_env_async.from_string('{% from "foo" import bar, with, context %}') 
-        test_env_async.from_string('{% from "foo" import bar, with with context %}') 
- 
-    def test_exports(self, test_env_async): 
+
+    def test_trailing_comma(self, test_env_async):
+        test_env_async.from_string('{% from "foo" import bar, baz with context %}')
+        test_env_async.from_string('{% from "foo" import bar, baz, with context %}')
+        test_env_async.from_string('{% from "foo" import bar, with context %}')
+        test_env_async.from_string('{% from "foo" import bar, with, context %}')
+        test_env_async.from_string('{% from "foo" import bar, with with context %}')
+
+    def test_exports(self, test_env_async):
         m = run(
             test_env_async.from_string(
                 """
-            {% macro toplevel() %}...{% endmacro %} 
-            {% macro __private() %}...{% endmacro %} 
-            {% set variable = 42 %} 
-            {% for item in [1] %} 
-                {% macro notthere() %}{% endmacro %} 
-            {% endfor %} 
+            {% macro toplevel() %}...{% endmacro %}
+            {% macro __private() %}...{% endmacro %}
+            {% set variable = 42 %}
+            {% for item in [1] %}
+                {% macro notthere() %}{% endmacro %}
+            {% endfor %}
         """
             )._get_default_module_async()
         )
         assert run(m.toplevel()) == "..."
         assert not hasattr(m, "__missing")
-        assert m.variable == 42 
+        assert m.variable == 42
         assert not hasattr(m, "notthere")
- 
- 
-class TestAsyncIncludes(object): 
-    def test_context_include(self, test_env_async): 
-        t = test_env_async.from_string('{% include "header" %}') 
+
+
+class TestAsyncIncludes(object):
+    def test_context_include(self, test_env_async):
+        t = test_env_async.from_string('{% include "header" %}')
         assert t.render(foo=42) == "[42|23]"
-        t = test_env_async.from_string('{% include "header" with context %}') 
+        t = test_env_async.from_string('{% include "header" with context %}')
         assert t.render(foo=42) == "[42|23]"
-        t = test_env_async.from_string('{% include "header" without context %}') 
+        t = test_env_async.from_string('{% include "header" without context %}')
         assert t.render(foo=42) == "[|23]"
- 
-    def test_choice_includes(self, test_env_async): 
-        t = test_env_async.from_string('{% include ["missing", "header"] %}') 
+
+    def test_choice_includes(self, test_env_async):
+        t = test_env_async.from_string('{% include ["missing", "header"] %}')
         assert t.render(foo=42) == "[42|23]"
- 
-        t = test_env_async.from_string( 
-            '{% include ["missing", "missing2"] ignore missing %}' 
-        ) 
+
+        t = test_env_async.from_string(
+            '{% include ["missing", "missing2"] ignore missing %}'
+        )
         assert t.render(foo=42) == ""
- 
-        t = test_env_async.from_string('{% include ["missing", "missing2"] %}') 
-        pytest.raises(TemplateNotFound, t.render) 
+
+        t = test_env_async.from_string('{% include ["missing", "missing2"] %}')
+        pytest.raises(TemplateNotFound, t.render)
         with pytest.raises(TemplatesNotFound) as e:
-            t.render() 
- 
+            t.render()
+
         assert e.value.templates == ["missing", "missing2"]
         assert e.value.name == "missing2"
 
-        def test_includes(t, **ctx): 
+        def test_includes(t, **ctx):
             ctx["foo"] = 42
             assert t.render(ctx) == "[42|23]"
- 
-        t = test_env_async.from_string('{% include ["missing", "header"] %}') 
-        test_includes(t) 
+
+        t = test_env_async.from_string('{% include ["missing", "header"] %}')
+        test_includes(t)
         t = test_env_async.from_string("{% include x %}")
         test_includes(t, x=["missing", "header"])
-        t = test_env_async.from_string('{% include [x, "header"] %}') 
+        t = test_env_async.from_string('{% include [x, "header"] %}')
         test_includes(t, x="missing")
         t = test_env_async.from_string("{% include x %}")
         test_includes(t, x="header")
@@ -221,17 +221,17 @@ class TestAsyncIncludes(object):
         test_includes(t, x="header")
         t = test_env_async.from_string("{% include [x] %}")
         test_includes(t, x="header")
- 
-    def test_include_ignoring_missing(self, test_env_async): 
-        t = test_env_async.from_string('{% include "missing" %}') 
-        pytest.raises(TemplateNotFound, t.render) 
+
+    def test_include_ignoring_missing(self, test_env_async):
+        t = test_env_async.from_string('{% include "missing" %}')
+        pytest.raises(TemplateNotFound, t.render)
         for extra in "", "with context", "without context":
             t = test_env_async.from_string(
                 '{% include "missing" ignore missing ' + extra + " %}"
             )
             assert t.render() == ""
- 
-    def test_context_include_with_overrides(self, test_env_async): 
+
+    def test_context_include_with_overrides(self, test_env_async):
         env = Environment(
             loader=DictLoader(
                 dict(
@@ -240,23 +240,23 @@ class TestAsyncIncludes(object):
                 )
             )
         )
-        assert env.get_template("main").render() == "123" 
- 
-    def test_unoptimized_scopes(self, test_env_async): 
+        assert env.get_template("main").render() == "123"
+
+    def test_unoptimized_scopes(self, test_env_async):
         t = test_env_async.from_string(
             """
-            {% macro outer(o) %} 
-            {% macro inner() %} 
-            {% include "o_printer" %} 
-            {% endmacro %} 
-            {{ inner() }} 
-            {% endmacro %} 
-            {{ outer("FOO") }} 
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
         """
         )
         assert t.render().strip() == "(FOO)"
- 
-    def test_unoptimized_scopes_autoescape(self): 
+
+    def test_unoptimized_scopes_autoescape(self):
         env = Environment(
             loader=DictLoader(dict(o_printer="({{ o }})",)),
             autoescape=True,
@@ -264,35 +264,35 @@ class TestAsyncIncludes(object):
         )
         t = env.from_string(
             """
-            {% macro outer(o) %} 
-            {% macro inner() %} 
-            {% include "o_printer" %} 
-            {% endmacro %} 
-            {{ inner() }} 
-            {% endmacro %} 
-            {{ outer("FOO") }} 
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
         """
         )
         assert t.render().strip() == "(FOO)"
- 
- 
-class TestAsyncForLoop(object): 
-    def test_simple(self, test_env_async): 
+
+
+class TestAsyncForLoop(object):
+    def test_simple(self, test_env_async):
         tmpl = test_env_async.from_string("{% for item in seq %}{{ item }}{% endfor %}")
         assert tmpl.render(seq=list(range(10))) == "0123456789"
- 
-    def test_else(self, test_env_async): 
-        tmpl = test_env_async.from_string( 
+
+    def test_else(self, test_env_async):
+        tmpl = test_env_async.from_string(
             "{% for item in seq %}XXX{% else %}...{% endfor %}"
         )
         assert tmpl.render() == "..."
- 
-    def test_empty_blocks(self, test_env_async): 
+
+    def test_empty_blocks(self, test_env_async):
         tmpl = test_env_async.from_string(
             "<{% for item in seq %}{% else %}{% endfor %}>"
         )
         assert tmpl.render() == "<>"
- 
+
     @pytest.mark.parametrize(
         "transform", [lambda x: x, iter, reversed, lambda x: (i for i in x), auto_aiter]
     )
@@ -304,59 +304,59 @@ class TestAsyncForLoop(object):
         )
         out = t.render(seq=transform([42, 24]))
         assert out == "1|0|2|1|True|False|2\n2|1|1|0|False|True|2\n"
- 
-    def test_cycling(self, test_env_async): 
+
+    def test_cycling(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in seq %}{{
-            loop.cycle('<1>', '<2>') }}{% endfor %}{% 
+            loop.cycle('<1>', '<2>') }}{% endfor %}{%
             for item in seq %}{{ loop.cycle(*through) }}{% endfor %}"""
         )
         output = tmpl.render(seq=list(range(4)), through=("<1>", "<2>"))
         assert output == "<1><2>" * 4
- 
-    def test_lookaround(self, test_env_async): 
+
+    def test_lookaround(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in seq -%}
-            {{ loop.previtem|default('x') }}-{{ item }}-{{ 
-            loop.nextitem|default('x') }}| 
+            {{ loop.previtem|default('x') }}-{{ item }}-{{
+            loop.nextitem|default('x') }}|
         {%- endfor %}"""
         )
-        output = tmpl.render(seq=list(range(4))) 
+        output = tmpl.render(seq=list(range(4)))
         assert output == "x-0-1|0-1-2|1-2-3|2-3-x|"
- 
-    def test_changed(self, test_env_async): 
+
+    def test_changed(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in seq -%}
-            {{ loop.changed(item) }}, 
+            {{ loop.changed(item) }},
         {%- endfor %}"""
         )
-        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4]) 
+        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4])
         assert output == "True,False,True,True,False,True,True,False,False,"
- 
-    def test_scope(self, test_env_async): 
+
+    def test_scope(self, test_env_async):
         tmpl = test_env_async.from_string("{% for item in seq %}{% endfor %}{{ item }}")
-        output = tmpl.render(seq=list(range(10))) 
-        assert not output 
- 
-    def test_varlen(self, test_env_async): 
-        def inner(): 
-            for item in range(5): 
-                yield item 
+        output = tmpl.render(seq=list(range(10)))
+        assert not output
+
+    def test_varlen(self, test_env_async):
+        def inner():
+            for item in range(5):
+                yield item
 
         tmpl = test_env_async.from_string(
             "{% for item in iter %}{{ item }}{% endfor %}"
         )
-        output = tmpl.render(iter=inner()) 
+        output = tmpl.render(iter=inner())
         assert output == "01234"
- 
-    def test_noniter(self, test_env_async): 
+
+    def test_noniter(self, test_env_async):
         tmpl = test_env_async.from_string("{% for item in none %}...{% endfor %}")
-        pytest.raises(TypeError, tmpl.render) 
- 
-    def test_recursive(self, test_env_async): 
+        pytest.raises(TypeError, tmpl.render)
+
+    def test_recursive(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in seq recursive -%}
-            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] 
+            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
         {%- endfor %}"""
         )
         assert (
@@ -369,13 +369,13 @@ class TestAsyncForLoop(object):
             )
             == "[1<[1][2]>][2<[1][2]>][3<[a]>]"
         )
- 
-    def test_recursive_lookaround(self, test_env_async): 
+
+    def test_recursive_lookaround(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in seq recursive -%}
-            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{ 
-            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x' 
-            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] 
+            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{
+            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x'
+            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
         {%- endfor %}"""
         )
         assert (
@@ -388,8 +388,8 @@ class TestAsyncForLoop(object):
             )
             == "[x.1.2<[x.1.2][1.2.x]>][1.2.3<[x.1.2][1.2.x]>][2.3.x<[x.a.x]>]"
         )
- 
-    def test_recursive_depth0(self, test_env_async): 
+
+    def test_recursive_depth0(self, test_env_async):
         tmpl = test_env_async.from_string(
             "{% for item in seq recursive %}[{{ loop.depth0 }}:{{ item.a }}"
             "{% if item.b %}<{{ loop(item.b) }}>{% endif %}]{% endfor %}"
@@ -404,8 +404,8 @@ class TestAsyncForLoop(object):
             )
             == "[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]"
         )
- 
-    def test_recursive_depth(self, test_env_async): 
+
+    def test_recursive_depth(self, test_env_async):
         tmpl = test_env_async.from_string(
             "{% for item in seq recursive %}[{{ loop.depth }}:{{ item.a }}"
             "{% if item.b %}<{{ loop(item.b) }}>{% endif %}]{% endfor %}"
@@ -420,58 +420,58 @@ class TestAsyncForLoop(object):
             )
             == "[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]"
         )
- 
-    def test_looploop(self, test_env_async): 
+
+    def test_looploop(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for row in table %}
-            {%- set rowloop = loop -%} 
-            {% for cell in row -%} 
-                [{{ rowloop.index }}|{{ loop.index }}] 
-            {%- endfor %} 
+            {%- set rowloop = loop -%}
+            {% for cell in row -%}
+                [{{ rowloop.index }}|{{ loop.index }}]
+            {%- endfor %}
         {%- endfor %}"""
         )
         assert tmpl.render(table=["ab", "cd"]) == "[1|1][1|2][2|1][2|2]"
- 
-    def test_reversed_bug(self, test_env_async): 
+
+    def test_reversed_bug(self, test_env_async):
         tmpl = test_env_async.from_string(
             "{% for i in items %}{{ i }}"
             "{% if not loop.last %}"
             ",{% endif %}{% endfor %}"
         )
         assert tmpl.render(items=reversed([3, 2, 1])) == "1,2,3"
- 
-    def test_loop_errors(self, test_env_async): 
+
+    def test_loop_errors(self, test_env_async):
         tmpl = test_env_async.from_string(
             """{% for item in [1] if loop.index
                                       == 0 %}...{% endfor %}"""
         )
-        pytest.raises(UndefinedError, tmpl.render) 
+        pytest.raises(UndefinedError, tmpl.render)
         tmpl = test_env_async.from_string(
             """{% for item in [] %}...{% else
             %}{{ loop }}{% endfor %}"""
         )
         assert tmpl.render() == ""
- 
-    def test_loop_filter(self, test_env_async): 
+
+    def test_loop_filter(self, test_env_async):
         tmpl = test_env_async.from_string(
             "{% for item in range(10) if item is even %}[{{ item }}]{% endfor %}"
         )
         assert tmpl.render() == "[0][2][4][6][8]"
         tmpl = test_env_async.from_string(
             """
-            {%- for item in range(10) if item is even %}[{{ 
+            {%- for item in range(10) if item is even %}[{{
                 loop.index }}:{{ item }}]{% endfor %}"""
         )
         assert tmpl.render() == "[1:0][2:2][3:4][4:6][5:8]"
- 
-    def test_scoped_special_var(self, test_env_async): 
-        t = test_env_async.from_string( 
+
+    def test_scoped_special_var(self, test_env_async):
+        t = test_env_async.from_string(
             "{% for s in seq %}[{{ loop.first }}{% for c in s %}"
             "|{{ loop.first }}{% endfor %}]{% endfor %}"
         )
         assert t.render(seq=("ab", "cd")) == "[True|True|False][False|True|False]"
- 
-    def test_scoped_loop_var(self, test_env_async): 
+
+    def test_scoped_loop_var(self, test_env_async):
         t = test_env_async.from_string(
             "{% for x in seq %}{{ loop.first }}"
             "{% for y in seq %}{% endfor %}{% endfor %}"
@@ -482,97 +482,97 @@ class TestAsyncForLoop(object):
             "{{ loop.first }}{% endfor %}{% endfor %}"
         )
         assert t.render(seq="ab") == "TrueFalseTrueFalse"
- 
-    def test_recursive_empty_loop_iter(self, test_env_async): 
+
+    def test_recursive_empty_loop_iter(self, test_env_async):
         t = test_env_async.from_string(
             """
-        {%- for item in foo recursive -%}{%- endfor -%} 
+        {%- for item in foo recursive -%}{%- endfor -%}
         """
         )
         assert t.render(dict(foo=[])) == ""
- 
-    def test_call_in_loop(self, test_env_async): 
+
+    def test_call_in_loop(self, test_env_async):
         t = test_env_async.from_string(
             """
-        {%- macro do_something() -%} 
-            [{{ caller() }}] 
-        {%- endmacro %} 
- 
-        {%- for i in [1, 2, 3] %} 
-            {%- call do_something() -%} 
-                {{ i }} 
-            {%- endcall %} 
-        {%- endfor -%} 
+        {%- macro do_something() -%}
+            [{{ caller() }}]
+        {%- endmacro %}
+
+        {%- for i in [1, 2, 3] %}
+            {%- call do_something() -%}
+                {{ i }}
+            {%- endcall %}
+        {%- endfor -%}
         """
         )
         assert t.render() == "[1][2][3]"
- 
-    def test_scoping_bug(self, test_env_async): 
+
+    def test_scoping_bug(self, test_env_async):
         t = test_env_async.from_string(
             """
-        {%- for item in foo %}...{{ item }}...{% endfor %} 
-        {%- macro item(a) %}...{{ a }}...{% endmacro %} 
-        {{- item(2) -}} 
+        {%- for item in foo %}...{{ item }}...{% endfor %}
+        {%- macro item(a) %}...{{ a }}...{% endmacro %}
+        {{- item(2) -}}
         """
         )
         assert t.render(foo=(1,)) == "...1......2..."
- 
-    def test_unpacking(self, test_env_async): 
+
+    def test_unpacking(self, test_env_async):
         tmpl = test_env_async.from_string(
             "{% for a, b, c in [[1, 2, 3]] %}{{ a }}|{{ b }}|{{ c }}{% endfor %}"
         )
         assert tmpl.render() == "1|2|3"
- 
-    def test_recursive_loop_filter(self, test_env_async): 
+
+    def test_recursive_loop_filter(self, test_env_async):
         t = test_env_async.from_string(
             """
-        <?xml version="1.0" encoding="UTF-8"?> 
-        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> 
-          {%- for page in [site.root] if page.url != this recursive %} 
-          <url><loc>{{ page.url }}</loc></url> 
-          {{- loop(page.children) }} 
-          {%- endfor %} 
-        </urlset> 
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in [site.root] if page.url != this recursive %}
+          <url><loc>{{ page.url }}</loc></url>
+          {{- loop(page.children) }}
+          {%- endfor %}
+        </urlset>
         """
         )
         sm = t.render(
             this="/foo",
             site={"root": {"url": "/", "children": [{"url": "/foo"}, {"url": "/bar"}]}},
         )
-        lines = [x.strip() for x in sm.splitlines() if x.strip()] 
-        assert lines == [ 
-            '<?xml version="1.0" encoding="UTF-8"?>', 
-            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">', 
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
             "<url><loc>/</loc></url>",
             "<url><loc>/bar</loc></url>",
             "</urlset>",
-        ] 
- 
-    def test_nonrecursive_loop_filter(self, test_env_async): 
+        ]
+
+    def test_nonrecursive_loop_filter(self, test_env_async):
         t = test_env_async.from_string(
             """
-        <?xml version="1.0" encoding="UTF-8"?> 
-        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> 
-          {%- for page in items if page.url != this %} 
-          <url><loc>{{ page.url }}</loc></url> 
-          {%- endfor %} 
-        </urlset> 
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in items if page.url != this %}
+          <url><loc>{{ page.url }}</loc></url>
+          {%- endfor %}
+        </urlset>
         """
         )
         sm = t.render(
             this="/foo", items=[{"url": "/"}, {"url": "/foo"}, {"url": "/bar"}]
         )
-        lines = [x.strip() for x in sm.splitlines() if x.strip()] 
-        assert lines == [ 
-            '<?xml version="1.0" encoding="UTF-8"?>', 
-            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">', 
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
             "<url><loc>/</loc></url>",
             "<url><loc>/bar</loc></url>",
             "</urlset>",
-        ] 
- 
-    def test_bare_async(self, test_env_async): 
-        t = test_env_async.from_string('{% extends "header" %}') 
+        ]
+
+    def test_bare_async(self, test_env_async):
+        t = test_env_async.from_string('{% extends "header" %}')
         assert t.render(foo=42) == "[42|23]"
 
     def test_awaitable_property_slicing(self, test_env_async):
diff --git a/contrib/python/Jinja2/py2/tests/test_asyncfilters.py b/contrib/python/Jinja2/py2/tests/test_asyncfilters.py
index 85c206be9d..7c737c835e 100644
--- a/contrib/python/Jinja2/py2/tests/test_asyncfilters.py
+++ b/contrib/python/Jinja2/py2/tests/test_asyncfilters.py
@@ -1,37 +1,37 @@
 from collections import namedtuple
 
-import pytest 
-
-from jinja2 import Environment 
-from jinja2.utils import Markup 
- 
- 
-async def make_aiter(iter): 
-    for item in iter: 
-        yield item 
- 
- 
-def mark_dualiter(parameter, factory): 
-    def decorator(f): 
+import pytest
+
+from jinja2 import Environment
+from jinja2.utils import Markup
+
+
+async def make_aiter(iter):
+    for item in iter:
+        yield item
+
+
+def mark_dualiter(parameter, factory):
+    def decorator(f):
         return pytest.mark.parametrize(
             parameter, [lambda: factory(), lambda: make_aiter(factory())]
         )(f)
 
-    return decorator 
- 
- 
-@pytest.fixture 
-def env_async(): 
-    return Environment(enable_async=True) 
- 
- 
+    return decorator
+
+
+@pytest.fixture
+def env_async():
+    return Environment(enable_async=True)
+
+
 @mark_dualiter("foo", lambda: range(10))
-def test_first(env_async, foo): 
+def test_first(env_async, foo):
     tmpl = env_async.from_string("{{ foo()|first }}")
-    out = tmpl.render(foo=foo) 
+    out = tmpl.render(foo=foo)
     assert out == "0"
- 
- 
+
+
 @mark_dualiter(
     "items",
     lambda: [
@@ -41,159 +41,159 @@ def test_first(env_async, foo):
         {"foo": 3, "bar": 4},
     ],
 )
-def test_groupby(env_async, items): 
+def test_groupby(env_async, items):
     tmpl = env_async.from_string(
         """
-    {%- for grouper, list in items()|groupby('foo') -%} 
-        {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}| 
+    {%- for grouper, list in items()|groupby('foo') -%}
+        {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}|
     {%- endfor %}"""
     )
     assert tmpl.render(items=items).split("|") == [
-        "1: 1, 2: 1, 1", 
-        "2: 2, 3", 
-        "3: 3, 4", 
+        "1: 1, 2: 1, 1",
+        "2: 2, 3",
+        "3: 3, 4",
         "",
-    ] 
- 
- 
+    ]
+
+
 @mark_dualiter("items", lambda: [("a", 1), ("a", 2), ("b", 1)])
-def test_groupby_tuple_index(env_async, items): 
+def test_groupby_tuple_index(env_async, items):
     tmpl = env_async.from_string(
         """
-    {%- for grouper, list in items()|groupby(0) -%} 
-        {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}| 
+    {%- for grouper, list in items()|groupby(0) -%}
+        {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}|
     {%- endfor %}"""
     )
     assert tmpl.render(items=items) == "a:1:2|b:1|"
- 
- 
-def make_articles(): 
+
+
+def make_articles():
     Date = namedtuple("Date", "day,month,year")
     Article = namedtuple("Article", "title,date")
-    return [ 
+    return [
         Article("aha", Date(1, 1, 1970)),
         Article("interesting", Date(2, 1, 1970)),
         Article("really?", Date(3, 1, 1970)),
         Article("totally not", Date(1, 1, 1971)),
-    ] 
- 
- 
+    ]
+
+
 @mark_dualiter("articles", make_articles)
-def test_groupby_multidot(env_async, articles): 
+def test_groupby_multidot(env_async, articles):
     tmpl = env_async.from_string(
         """
-    {%- for year, list in articles()|groupby('date.year') -%} 
-        {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}| 
+    {%- for year, list in articles()|groupby('date.year') -%}
+        {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}|
     {%- endfor %}"""
     )
     assert tmpl.render(articles=articles).split("|") == [
         "1970[aha][interesting][really?]",
         "1971[totally not]",
         "",
-    ] 
- 
- 
+    ]
+
+
 @mark_dualiter("int_items", lambda: [1, 2, 3])
 def test_join_env_int(env_async, int_items):
-    tmpl = env_async.from_string('{{ items()|join("|") }}') 
-    out = tmpl.render(items=int_items) 
+    tmpl = env_async.from_string('{{ items()|join("|") }}')
+    out = tmpl.render(items=int_items)
     assert out == "1|2|3"
- 
- 
+
+
 @mark_dualiter("string_items", lambda: ["<foo>", Markup("<span>foo</span>")])
 def test_join_string_list(string_items):
-    env2 = Environment(autoescape=True, enable_async=True) 
+    env2 = Environment(autoescape=True, enable_async=True)
     tmpl = env2.from_string('{{ ["<foo>", "<span>foo</span>"|safe]|join }}')
     assert tmpl.render(items=string_items) == "&lt;foo&gt;<span>foo</span>"
- 
- 
-def make_users(): 
+
+
+def make_users():
     User = namedtuple("User", "username")
     return map(User, ["foo", "bar"])
- 
- 
+
+
 @mark_dualiter("users", make_users)
-def test_join_attribute(env_async, users): 
+def test_join_attribute(env_async, users):
     tmpl = env_async.from_string("""{{ users()|join(', ', 'username') }}""")
     assert tmpl.render(users=users) == "foo, bar"
- 
- 
+
+
 @mark_dualiter("items", lambda: [1, 2, 3, 4, 5])
-def test_simple_reject(env_async, items): 
-    tmpl = env_async.from_string('{{ items()|reject("odd")|join("|") }}') 
+def test_simple_reject(env_async, items):
+    tmpl = env_async.from_string('{{ items()|reject("odd")|join("|") }}')
     assert tmpl.render(items=items) == "2|4"
- 
- 
+
+
 @mark_dualiter("items", lambda: [None, False, 0, 1, 2, 3, 4, 5])
-def test_bool_reject(env_async, items): 
+def test_bool_reject(env_async, items):
     tmpl = env_async.from_string('{{ items()|reject|join("|") }}')
     assert tmpl.render(items=items) == "None|False|0"
- 
- 
+
+
 @mark_dualiter("items", lambda: [1, 2, 3, 4, 5])
-def test_simple_select(env_async, items): 
-    tmpl = env_async.from_string('{{ items()|select("odd")|join("|") }}') 
+def test_simple_select(env_async, items):
+    tmpl = env_async.from_string('{{ items()|select("odd")|join("|") }}')
     assert tmpl.render(items=items) == "1|3|5"
- 
- 
+
+
 @mark_dualiter("items", lambda: [None, False, 0, 1, 2, 3, 4, 5])
-def test_bool_select(env_async, items): 
+def test_bool_select(env_async, items):
     tmpl = env_async.from_string('{{ items()|select|join("|") }}')
     assert tmpl.render(items=items) == "1|2|3|4|5"
- 
- 
-def make_users(): 
+
+
+def make_users():
     User = namedtuple("User", "name,is_active")
-    return [ 
+    return [
         User("john", True),
         User("jane", True),
         User("mike", False),
-    ] 
- 
- 
+    ]
+
+
 @mark_dualiter("users", make_users)
-def test_simple_select_attr(env_async, users): 
-    tmpl = env_async.from_string( 
+def test_simple_select_attr(env_async, users):
+    tmpl = env_async.from_string(
         '{{ users()|selectattr("is_active")|map(attribute="name")|join("|") }}'
-    ) 
+    )
     assert tmpl.render(users=users) == "john|jane"
- 
- 
+
+
 @mark_dualiter("items", lambda: list("123"))
-def test_simple_map(env_async, items): 
-    tmpl = env_async.from_string('{{ items()|map("int")|sum }}') 
+def test_simple_map(env_async, items):
+    tmpl = env_async.from_string('{{ items()|map("int")|sum }}')
     assert tmpl.render(items=items) == "6"
- 
- 
+
+
 def test_map_sum(env_async):  # async map + async filter
     tmpl = env_async.from_string('{{ [[1,2], [3], [4,5,6]]|map("sum")|list }}')
     assert tmpl.render() == "[3, 3, 15]"
 
 
 @mark_dualiter("users", make_users)
-def test_attribute_map(env_async, users): 
-    tmpl = env_async.from_string('{{ users()|map(attribute="name")|join("|") }}') 
+def test_attribute_map(env_async, users):
+    tmpl = env_async.from_string('{{ users()|map(attribute="name")|join("|") }}')
     assert tmpl.render(users=users) == "john|jane|mike"
- 
- 
-def test_empty_map(env_async): 
-    tmpl = env_async.from_string('{{ none|map("upper")|list }}') 
+
+
+def test_empty_map(env_async):
+    tmpl = env_async.from_string('{{ none|map("upper")|list }}')
     assert tmpl.render() == "[]"
- 
- 
+
+
 @mark_dualiter("items", lambda: [1, 2, 3, 4, 5, 6])
-def test_sum(env_async, items): 
+def test_sum(env_async, items):
     tmpl = env_async.from_string("""{{ items()|sum }}""")
     assert tmpl.render(items=items) == "21"
- 
- 
+
+
 @mark_dualiter("items", lambda: [{"value": 23}, {"value": 1}, {"value": 18}])
-def test_sum_attributes(env_async, items): 
+def test_sum_attributes(env_async, items):
     tmpl = env_async.from_string("""{{ items()|sum('value') }}""")
-    assert tmpl.render(items=items) 
- 
- 
-def test_sum_attributes_nested(env_async): 
+    assert tmpl.render(items=items)
+
+
+def test_sum_attributes_nested(env_async):
     tmpl = env_async.from_string("""{{ values|sum('real.value') }}""")
     assert (
         tmpl.render(
@@ -205,19 +205,19 @@ def test_sum_attributes_nested(env_async):
         )
         == "42"
     )
- 
- 
-def test_sum_attributes_tuple(env_async): 
+
+
+def test_sum_attributes_tuple(env_async):
     tmpl = env_async.from_string("""{{ values.items()|sum('1') }}""")
     assert tmpl.render(values={"foo": 23, "bar": 1, "baz": 18}) == "42"
- 
- 
+
+
 @mark_dualiter("items", lambda: range(10))
-def test_slice(env_async, items): 
+def test_slice(env_async, items):
     tmpl = env_async.from_string(
         "{{ items()|slice(3)|list }}|{{ items()|slice(3, 'X')|list }}"
     )
-    out = tmpl.render(items=items) 
+    out = tmpl.render(items=items)
     assert out == (
         "[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|"
         "[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]"
diff --git a/contrib/python/Jinja2/py2/tests/test_bytecode_cache.py b/contrib/python/Jinja2/py2/tests/test_bytecode_cache.py
index 9a98dc4baa..c7882b1a2d 100644
--- a/contrib/python/Jinja2/py2/tests/test_bytecode_cache.py
+++ b/contrib/python/Jinja2/py2/tests/test_bytecode_cache.py
@@ -1,78 +1,78 @@
-# -*- coding: utf-8 -*- 
-import pytest 
- 
-from jinja2 import Environment 
+# -*- coding: utf-8 -*-
+import pytest
+
+from jinja2 import Environment
 from jinja2.bccache import Bucket
 from jinja2.bccache import FileSystemBytecodeCache
 from jinja2.bccache import MemcachedBytecodeCache
-from jinja2.exceptions import TemplateNotFound 
- 
- 
-@pytest.fixture 
+from jinja2.exceptions import TemplateNotFound
+
+
+@pytest.fixture
 def env(package_loader, tmp_path):
     bytecode_cache = FileSystemBytecodeCache(str(tmp_path))
     return Environment(loader=package_loader, bytecode_cache=bytecode_cache)
- 
- 
-class TestByteCodeCache(object): 
-    def test_simple(self, env): 
+
+
+class TestByteCodeCache(object):
+    def test_simple(self, env):
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")
- 
- 
-class MockMemcached(object): 
-    class Error(Exception): 
-        pass 
- 
-    key = None 
-    value = None 
-    timeout = None 
- 
-    def get(self, key): 
-        return self.value 
- 
-    def set(self, key, value, timeout=None): 
-        self.key = key 
-        self.value = value 
-        self.timeout = timeout 
- 
-    def get_side_effect(self, key): 
-        raise self.Error() 
- 
-    def set_side_effect(self, *args): 
-        raise self.Error() 
- 
- 
-class TestMemcachedBytecodeCache(object): 
-    def test_dump_load(self): 
-        memcached = MockMemcached() 
-        m = MemcachedBytecodeCache(memcached) 
- 
+
+
+class MockMemcached(object):
+    class Error(Exception):
+        pass
+
+    key = None
+    value = None
+    timeout = None
+
+    def get(self, key):
+        return self.value
+
+    def set(self, key, value, timeout=None):
+        self.key = key
+        self.value = value
+        self.timeout = timeout
+
+    def get_side_effect(self, key):
+        raise self.Error()
+
+    def set_side_effect(self, *args):
+        raise self.Error()
+
+
+class TestMemcachedBytecodeCache(object):
+    def test_dump_load(self):
+        memcached = MockMemcached()
+        m = MemcachedBytecodeCache(memcached)
+
         b = Bucket(None, "key", "")
         b.code = "code"
-        m.dump_bytecode(b) 
+        m.dump_bytecode(b)
         assert memcached.key == "jinja2/bytecode/key"
- 
+
         b = Bucket(None, "key", "")
-        m.load_bytecode(b) 
+        m.load_bytecode(b)
         assert b.code == "code"
- 
-    def test_exception(self): 
-        memcached = MockMemcached() 
-        memcached.get = memcached.get_side_effect 
-        memcached.set = memcached.set_side_effect 
-        m = MemcachedBytecodeCache(memcached) 
+
+    def test_exception(self):
+        memcached = MockMemcached()
+        memcached.get = memcached.get_side_effect
+        memcached.set = memcached.set_side_effect
+        m = MemcachedBytecodeCache(memcached)
         b = Bucket(None, "key", "")
         b.code = "code"
- 
-        m.dump_bytecode(b) 
-        m.load_bytecode(b) 
- 
-        m.ignore_memcache_errors = False 
- 
-        with pytest.raises(MockMemcached.Error): 
-            m.dump_bytecode(b) 
- 
-        with pytest.raises(MockMemcached.Error): 
-            m.load_bytecode(b) 
+
+        m.dump_bytecode(b)
+        m.load_bytecode(b)
+
+        m.ignore_memcache_errors = False
+
+        with pytest.raises(MockMemcached.Error):
+            m.dump_bytecode(b)
+
+        with pytest.raises(MockMemcached.Error):
+            m.load_bytecode(b)
diff --git a/contrib/python/Jinja2/py2/tests/test_core_tags.py b/contrib/python/Jinja2/py2/tests/test_core_tags.py
index 0c4f4ac0ba..1bd96c41e9 100644
--- a/contrib/python/Jinja2/py2/tests/test_core_tags.py
+++ b/contrib/python/Jinja2/py2/tests/test_core_tags.py
@@ -1,42 +1,42 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import pytest
- 
+
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2 import TemplateRuntimeError
 from jinja2 import TemplateSyntaxError
 from jinja2 import UndefinedError
- 
- 
-@pytest.fixture 
-def env_trim(): 
-    return Environment(trim_blocks=True) 
- 
- 
-class TestForLoop(object): 
-    def test_simple(self, env): 
+
+
+@pytest.fixture
+def env_trim():
+    return Environment(trim_blocks=True)
+
+
+class TestForLoop(object):
+    def test_simple(self, env):
         tmpl = env.from_string("{% for item in seq %}{{ item }}{% endfor %}")
         assert tmpl.render(seq=list(range(10))) == "0123456789"
- 
-    def test_else(self, env): 
+
+    def test_else(self, env):
         tmpl = env.from_string("{% for item in seq %}XXX{% else %}...{% endfor %}")
         assert tmpl.render() == "..."
- 
-    def test_else_scoping_item(self, env): 
+
+    def test_else_scoping_item(self, env):
         tmpl = env.from_string("{% for item in [] %}{% else %}{{ item }}{% endfor %}")
         assert tmpl.render(item=42) == "42"
- 
-    def test_empty_blocks(self, env): 
+
+    def test_empty_blocks(self, env):
         tmpl = env.from_string("<{% for item in seq %}{% else %}{% endfor %}>")
         assert tmpl.render() == "<>"
- 
-    def test_context_vars(self, env): 
-        slist = [42, 24] 
-        for seq in [slist, iter(slist), reversed(slist), (_ for _ in slist)]: 
+
+    def test_context_vars(self, env):
+        slist = [42, 24]
+        for seq in [slist, iter(slist), reversed(slist), (_ for _ in slist)]:
             tmpl = env.from_string(
                 """{% for item in seq -%}
-            {{ loop.index }}|{{ loop.index0 }}|{{ loop.revindex }}|{{ 
-                loop.revindex0 }}|{{ loop.first }}|{{ loop.last }}|{{ 
+            {{ loop.index }}|{{ loop.index0 }}|{{ loop.revindex }}|{{
+                loop.revindex0 }}|{{ loop.first }}|{{ loop.last }}|{{
                loop.length }}###{% endfor %}"""
             )
             one, two, _ = tmpl.render(seq=seq).split("###")
@@ -58,65 +58,65 @@ class TestForLoop(object):
                 two_last,
                 two_length,
             ) = two.split("|")
- 
-            assert int(one_index) == 1 and int(two_index) == 2 
-            assert int(one_index0) == 0 and int(two_index0) == 1 
-            assert int(one_revindex) == 2 and int(two_revindex) == 1 
-            assert int(one_revindex0) == 1 and int(two_revindex0) == 0 
+
+            assert int(one_index) == 1 and int(two_index) == 2
+            assert int(one_index0) == 0 and int(two_index0) == 1
+            assert int(one_revindex) == 2 and int(two_revindex) == 1
+            assert int(one_revindex0) == 1 and int(two_revindex0) == 0
             assert one_first == "True" and two_first == "False"
             assert one_last == "False" and two_last == "True"
             assert one_length == two_length == "2"
- 
-    def test_cycling(self, env): 
+
+    def test_cycling(self, env):
         tmpl = env.from_string(
             """{% for item in seq %}{{
-            loop.cycle('<1>', '<2>') }}{% endfor %}{% 
+            loop.cycle('<1>', '<2>') }}{% endfor %}{%
             for item in seq %}{{ loop.cycle(*through) }}{% endfor %}"""
         )
         output = tmpl.render(seq=list(range(4)), through=("<1>", "<2>"))
         assert output == "<1><2>" * 4
- 
-    def test_lookaround(self, env): 
+
+    def test_lookaround(self, env):
         tmpl = env.from_string(
             """{% for item in seq -%}
-            {{ loop.previtem|default('x') }}-{{ item }}-{{ 
-            loop.nextitem|default('x') }}| 
+            {{ loop.previtem|default('x') }}-{{ item }}-{{
+            loop.nextitem|default('x') }}|
         {%- endfor %}"""
         )
-        output = tmpl.render(seq=list(range(4))) 
+        output = tmpl.render(seq=list(range(4)))
         assert output == "x-0-1|0-1-2|1-2-3|2-3-x|"
- 
-    def test_changed(self, env): 
+
+    def test_changed(self, env):
         tmpl = env.from_string(
             """{% for item in seq -%}
-            {{ loop.changed(item) }}, 
+            {{ loop.changed(item) }},
         {%- endfor %}"""
         )
-        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4]) 
+        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4])
         assert output == "True,False,True,True,False,True,True,False,False,"
- 
-    def test_scope(self, env): 
+
+    def test_scope(self, env):
         tmpl = env.from_string("{% for item in seq %}{% endfor %}{{ item }}")
-        output = tmpl.render(seq=list(range(10))) 
-        assert not output 
- 
-    def test_varlen(self, env): 
-        def inner(): 
-            for item in range(5): 
-                yield item 
+        output = tmpl.render(seq=list(range(10)))
+        assert not output
+
+    def test_varlen(self, env):
+        def inner():
+            for item in range(5):
+                yield item
 
         tmpl = env.from_string("{% for item in iter %}{{ item }}{% endfor %}")
-        output = tmpl.render(iter=inner()) 
+        output = tmpl.render(iter=inner())
         assert output == "01234"
- 
-    def test_noniter(self, env): 
+
+    def test_noniter(self, env):
         tmpl = env.from_string("{% for item in none %}...{% endfor %}")
-        pytest.raises(TypeError, tmpl.render) 
- 
-    def test_recursive(self, env): 
+        pytest.raises(TypeError, tmpl.render)
+
+    def test_recursive(self, env):
         tmpl = env.from_string(
             """{% for item in seq recursive -%}
-            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] 
+            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
         {%- endfor %}"""
         )
         assert (
@@ -129,13 +129,13 @@ class TestForLoop(object):
             )
             == "[1<[1][2]>][2<[1][2]>][3<[a]>]"
         )
- 
-    def test_recursive_lookaround(self, env): 
+
+    def test_recursive_lookaround(self, env):
         tmpl = env.from_string(
             """{% for item in seq recursive -%}
-            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{ 
-            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x' 
-            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] 
+            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{
+            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x'
+            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
         {%- endfor %}"""
         )
         assert (
@@ -148,8 +148,8 @@ class TestForLoop(object):
             )
             == "[x.1.2<[x.1.2][1.2.x]>][1.2.3<[x.1.2][1.2.x]>][2.3.x<[x.a.x]>]"
         )
- 
-    def test_recursive_depth0(self, env): 
+
+    def test_recursive_depth0(self, env):
         tmpl = env.from_string(
             """{% for item in seq recursive -%}
         [{{ loop.depth0 }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
@@ -165,8 +165,8 @@ class TestForLoop(object):
             )
             == "[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]"
         )
- 
-    def test_recursive_depth(self, env): 
+
+    def test_recursive_depth(self, env):
         tmpl = env.from_string(
             """{% for item in seq recursive -%}
         [{{ loop.depth }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
@@ -182,63 +182,63 @@ class TestForLoop(object):
             )
             == "[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]"
         )
- 
-    def test_looploop(self, env): 
+
+    def test_looploop(self, env):
         tmpl = env.from_string(
             """{% for row in table %}
-            {%- set rowloop = loop -%} 
-            {% for cell in row -%} 
-                [{{ rowloop.index }}|{{ loop.index }}] 
-            {%- endfor %} 
+            {%- set rowloop = loop -%}
+            {% for cell in row -%}
+                [{{ rowloop.index }}|{{ loop.index }}]
+            {%- endfor %}
         {%- endfor %}"""
         )
         assert tmpl.render(table=["ab", "cd"]) == "[1|1][1|2][2|1][2|2]"
- 
-    def test_reversed_bug(self, env): 
+
+    def test_reversed_bug(self, env):
         tmpl = env.from_string(
             "{% for i in items %}{{ i }}"
             "{% if not loop.last %}"
             ",{% endif %}{% endfor %}"
         )
         assert tmpl.render(items=reversed([3, 2, 1])) == "1,2,3"
- 
-    def test_loop_errors(self, env): 
+
+    def test_loop_errors(self, env):
         tmpl = env.from_string(
             """{% for item in [1] if loop.index
                                       == 0 %}...{% endfor %}"""
         )
-        pytest.raises(UndefinedError, tmpl.render) 
+        pytest.raises(UndefinedError, tmpl.render)
         tmpl = env.from_string(
             """{% for item in [] %}...{% else
             %}{{ loop }}{% endfor %}"""
         )
         assert tmpl.render() == ""
- 
-    def test_loop_filter(self, env): 
+
+    def test_loop_filter(self, env):
         tmpl = env.from_string(
             "{% for item in range(10) if item is even %}[{{ item }}]{% endfor %}"
         )
         assert tmpl.render() == "[0][2][4][6][8]"
         tmpl = env.from_string(
             """
-            {%- for item in range(10) if item is even %}[{{ 
+            {%- for item in range(10) if item is even %}[{{
                 loop.index }}:{{ item }}]{% endfor %}"""
         )
         assert tmpl.render() == "[1:0][2:2][3:4][4:6][5:8]"
- 
-    def test_loop_unassignable(self, env): 
+
+    def test_loop_unassignable(self, env):
         pytest.raises(
             TemplateSyntaxError, env.from_string, "{% for loop in seq %}...{% endfor %}"
         )
- 
-    def test_scoped_special_var(self, env): 
-        t = env.from_string( 
+
+    def test_scoped_special_var(self, env):
+        t = env.from_string(
             "{% for s in seq %}[{{ loop.first }}{% for c in s %}"
             "|{{ loop.first }}{% endfor %}]{% endfor %}"
         )
         assert t.render(seq=("ab", "cd")) == "[True|True|False][False|True|False]"
- 
-    def test_scoped_loop_var(self, env): 
+
+    def test_scoped_loop_var(self, env):
         t = env.from_string(
             "{% for x in seq %}{{ loop.first }}"
             "{% for y in seq %}{% endfor %}{% endfor %}"
@@ -249,278 +249,278 @@ class TestForLoop(object):
             "{{ loop.first }}{% endfor %}{% endfor %}"
         )
         assert t.render(seq="ab") == "TrueFalseTrueFalse"
- 
-    def test_recursive_empty_loop_iter(self, env): 
+
+    def test_recursive_empty_loop_iter(self, env):
         t = env.from_string(
             """
-        {%- for item in foo recursive -%}{%- endfor -%} 
+        {%- for item in foo recursive -%}{%- endfor -%}
         """
         )
         assert t.render(dict(foo=[])) == ""
- 
-    def test_call_in_loop(self, env): 
+
+    def test_call_in_loop(self, env):
         t = env.from_string(
             """
-        {%- macro do_something() -%} 
-            [{{ caller() }}] 
-        {%- endmacro %} 
- 
-        {%- for i in [1, 2, 3] %} 
-            {%- call do_something() -%} 
-                {{ i }} 
-            {%- endcall %} 
-        {%- endfor -%} 
+        {%- macro do_something() -%}
+            [{{ caller() }}]
+        {%- endmacro %}
+
+        {%- for i in [1, 2, 3] %}
+            {%- call do_something() -%}
+                {{ i }}
+            {%- endcall %}
+        {%- endfor -%}
         """
         )
         assert t.render() == "[1][2][3]"
- 
-    def test_scoping_bug(self, env): 
+
+    def test_scoping_bug(self, env):
         t = env.from_string(
             """
-        {%- for item in foo %}...{{ item }}...{% endfor %} 
-        {%- macro item(a) %}...{{ a }}...{% endmacro %} 
-        {{- item(2) -}} 
+        {%- for item in foo %}...{{ item }}...{% endfor %}
+        {%- macro item(a) %}...{{ a }}...{% endmacro %}
+        {{- item(2) -}}
         """
         )
         assert t.render(foo=(1,)) == "...1......2..."
- 
-    def test_unpacking(self, env): 
+
+    def test_unpacking(self, env):
         tmpl = env.from_string(
             "{% for a, b, c in [[1, 2, 3]] %}{{ a }}|{{ b }}|{{ c }}{% endfor %}"
         )
         assert tmpl.render() == "1|2|3"
- 
-    def test_intended_scoping_with_set(self, env): 
+
+    def test_intended_scoping_with_set(self, env):
         tmpl = env.from_string(
             "{% for item in seq %}{{ x }}{% set x = item %}{{ x }}{% endfor %}"
         )
         assert tmpl.render(x=0, seq=[1, 2, 3]) == "010203"
- 
+
         tmpl = env.from_string(
             "{% set x = 9 %}{% for item in seq %}{{ x }}"
             "{% set x = item %}{{ x }}{% endfor %}"
         )
         assert tmpl.render(x=0, seq=[1, 2, 3]) == "919293"
- 
- 
-class TestIfCondition(object): 
-    def test_simple(self, env): 
+
+
+class TestIfCondition(object):
+    def test_simple(self, env):
         tmpl = env.from_string("""{% if true %}...{% endif %}""")
         assert tmpl.render() == "..."
- 
-    def test_elif(self, env): 
+
+    def test_elif(self, env):
         tmpl = env.from_string(
             """{% if false %}XXX{% elif true
             %}...{% else %}XXX{% endif %}"""
         )
         assert tmpl.render() == "..."
- 
-    def test_elif_deep(self, env): 
+
+    def test_elif_deep(self, env):
         elifs = "\n".join("{{% elif a == {0} %}}{0}".format(i) for i in range(1, 1000))
         tmpl = env.from_string(
             "{{% if a == 0 %}}0{0}{{% else %}}x{{% endif %}}".format(elifs)
         )
-        for x in (0, 10, 999): 
-            assert tmpl.render(a=x).strip() == str(x) 
+        for x in (0, 10, 999):
+            assert tmpl.render(a=x).strip() == str(x)
         assert tmpl.render(a=1000).strip() == "x"
- 
-    def test_else(self, env): 
+
+    def test_else(self, env):
         tmpl = env.from_string("{% if false %}XXX{% else %}...{% endif %}")
         assert tmpl.render() == "..."
- 
-    def test_empty(self, env): 
+
+    def test_empty(self, env):
         tmpl = env.from_string("[{% if true %}{% else %}{% endif %}]")
         assert tmpl.render() == "[]"
- 
-    def test_complete(self, env): 
+
+    def test_complete(self, env):
         tmpl = env.from_string(
             "{% if a %}A{% elif b %}B{% elif c == d %}C{% else %}D{% endif %}"
         )
         assert tmpl.render(a=0, b=False, c=42, d=42.0) == "C"
- 
-    def test_no_scope(self, env): 
+
+    def test_no_scope(self, env):
         tmpl = env.from_string("{% if a %}{% set foo = 1 %}{% endif %}{{ foo }}")
         assert tmpl.render(a=True) == "1"
         tmpl = env.from_string("{% if true %}{% set foo = 1 %}{% endif %}{{ foo }}")
         assert tmpl.render() == "1"
- 
- 
-class TestMacros(object): 
-    def test_simple(self, env_trim): 
+
+
+class TestMacros(object):
+    def test_simple(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %} 
+{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %}
 {{ say_hello('Peter') }}"""
         )
         assert tmpl.render() == "Hello Peter!"
- 
-    def test_scoping(self, env_trim): 
+
+    def test_scoping(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro level1(data1) %} 
-{% macro level2(data2) %}{{ data1 }}|{{ data2 }}{% endmacro %} 
-{{ level2('bar') }}{% endmacro %} 
+{% macro level1(data1) %}
+{% macro level2(data2) %}{{ data1 }}|{{ data2 }}{% endmacro %}
+{{ level2('bar') }}{% endmacro %}
 {{ level1('foo') }}"""
         )
         assert tmpl.render() == "foo|bar"
- 
-    def test_arguments(self, env_trim): 
+
+    def test_arguments(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro m(a, b, c='c', d='d') %}{{ a }}|{{ b }}|{{ c }}|{{ d }}{% endmacro %} 
+{% macro m(a, b, c='c', d='d') %}{{ a }}|{{ b }}|{{ c }}|{{ d }}{% endmacro %}
 {{ m() }}|{{ m('a') }}|{{ m('a', 'b') }}|{{ m(1, 2, 3) }}"""
         )
         assert tmpl.render() == "||c|d|a||c|d|a|b|c|d|1|2|3|d"
- 
-    def test_arguments_defaults_nonsense(self, env_trim): 
+
+    def test_arguments_defaults_nonsense(self, env_trim):
         pytest.raises(
             TemplateSyntaxError,
             env_trim.from_string,
             """\
 {% macro m(a, b=1, c) %}a={{ a }}, b={{ b }}, c={{ c }}{% endmacro %}""",
         )
- 
-    def test_caller_defaults_nonsense(self, env_trim): 
+
+    def test_caller_defaults_nonsense(self, env_trim):
         pytest.raises(
             TemplateSyntaxError,
             env_trim.from_string,
             """\
-{% macro a() %}{{ caller() }}{% endmacro %} 
+{% macro a() %}{{ caller() }}{% endmacro %}
 {% call(x, y=1, z) a() %}{% endcall %}""",
         )
- 
-    def test_varargs(self, env_trim): 
+
+    def test_varargs(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro test() %}{{ varargs|join('|') }}{% endmacro %}\ 
+{% macro test() %}{{ varargs|join('|') }}{% endmacro %}\
 {{ test(1, 2, 3) }}"""
         )
         assert tmpl.render() == "1|2|3"
- 
-    def test_simple_call(self, env_trim): 
+
+    def test_simple_call(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro test() %}[[{{ caller() }}]]{% endmacro %}\ 
+{% macro test() %}[[{{ caller() }}]]{% endmacro %}\
 {% call test() %}data{% endcall %}"""
         )
         assert tmpl.render() == "[[data]]"
- 
-    def test_complex_call(self, env_trim): 
+
+    def test_complex_call(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% macro test() %}[[{{ caller('data') }}]]{% endmacro %}\ 
+{% macro test() %}[[{{ caller('data') }}]]{% endmacro %}\
 {% call(data) test() %}{{ data }}{% endcall %}"""
         )
         assert tmpl.render() == "[[data]]"
- 
-    def test_caller_undefined(self, env_trim): 
+
+    def test_caller_undefined(self, env_trim):
         tmpl = env_trim.from_string(
             """\
-{% set caller = 42 %}\ 
-{% macro test() %}{{ caller is not defined }}{% endmacro %}\ 
+{% set caller = 42 %}\
+{% macro test() %}{{ caller is not defined }}{% endmacro %}\
 {{ test() }}"""
         )
         assert tmpl.render() == "True"
- 
-    def test_include(self, env_trim): 
-        env_trim = Environment( 
+
+    def test_include(self, env_trim):
+        env_trim = Environment(
             loader=DictLoader(
                 {"include": "{% macro test(foo) %}[{{ foo }}]{% endmacro %}"}
             )
-        ) 
+        )
         tmpl = env_trim.from_string('{% from "include" import test %}{{ test("foo") }}')
         assert tmpl.render() == "[foo]"
- 
-    def test_macro_api(self, env_trim): 
-        tmpl = env_trim.from_string( 
+
+    def test_macro_api(self, env_trim):
+        tmpl = env_trim.from_string(
             "{% macro foo(a, b) %}{% endmacro %}"
             "{% macro bar() %}{{ varargs }}{{ kwargs }}{% endmacro %}"
             "{% macro baz() %}{{ caller() }}{% endmacro %}"
         )
         assert tmpl.module.foo.arguments == ("a", "b")
         assert tmpl.module.foo.name == "foo"
-        assert not tmpl.module.foo.caller 
-        assert not tmpl.module.foo.catch_kwargs 
-        assert not tmpl.module.foo.catch_varargs 
-        assert tmpl.module.bar.arguments == () 
-        assert not tmpl.module.bar.caller 
-        assert tmpl.module.bar.catch_kwargs 
-        assert tmpl.module.bar.catch_varargs 
-        assert tmpl.module.baz.caller 
- 
-    def test_callself(self, env_trim): 
+        assert not tmpl.module.foo.caller
+        assert not tmpl.module.foo.catch_kwargs
+        assert not tmpl.module.foo.catch_varargs
+        assert tmpl.module.bar.arguments == ()
+        assert not tmpl.module.bar.caller
+        assert tmpl.module.bar.catch_kwargs
+        assert tmpl.module.bar.catch_varargs
+        assert tmpl.module.baz.caller
+
+    def test_callself(self, env_trim):
         tmpl = env_trim.from_string(
             "{% macro foo(x) %}{{ x }}{% if x > 1 %}|"
             "{{ foo(x - 1) }}{% endif %}{% endmacro %}"
             "{{ foo(5) }}"
         )
         assert tmpl.render() == "5|4|3|2|1"
- 
-    def test_macro_defaults_self_ref(self, env): 
+
+    def test_macro_defaults_self_ref(self, env):
         tmpl = env.from_string(
             """
-            {%- set x = 42 %} 
-            {%- macro m(a, b=x, x=23) %}{{ a }}|{{ b }}|{{ x }}{% endmacro -%} 
+            {%- set x = 42 %}
+            {%- macro m(a, b=x, x=23) %}{{ a }}|{{ b }}|{{ x }}{% endmacro -%}
         """
         )
         assert tmpl.module.m(1) == "1||23"
         assert tmpl.module.m(1, 2) == "1|2|23"
         assert tmpl.module.m(1, 2, 3) == "1|2|3"
         assert tmpl.module.m(1, x=7) == "1|7|7"
- 
- 
-class TestSet(object): 
-    def test_normal(self, env_trim): 
+
+
+class TestSet(object):
+    def test_normal(self, env_trim):
         tmpl = env_trim.from_string("{% set foo = 1 %}{{ foo }}")
         assert tmpl.render() == "1"
-        assert tmpl.module.foo == 1 
- 
-    def test_block(self, env_trim): 
+        assert tmpl.module.foo == 1
+
+    def test_block(self, env_trim):
         tmpl = env_trim.from_string("{% set foo %}42{% endset %}{{ foo }}")
         assert tmpl.render() == "42"
         assert tmpl.module.foo == u"42"
- 
-    def test_block_escaping(self): 
-        env = Environment(autoescape=True) 
+
+    def test_block_escaping(self):
+        env = Environment(autoescape=True)
         tmpl = env.from_string(
             "{% set foo %}<em>{{ test }}</em>{% endset %}foo: {{ foo }}"
         )
         assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"
- 
-    def test_set_invalid(self, env_trim): 
+
+    def test_set_invalid(self, env_trim):
         pytest.raises(
             TemplateSyntaxError, env_trim.from_string, "{% set foo['bar'] = 1 %}"
         )
         tmpl = env_trim.from_string("{% set foo.bar = 1 %}")
-        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, foo={}) 
+        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, foo={})
         assert "non-namespace object" in exc_info.value.message
- 
-    def test_namespace_redefined(self, env_trim): 
+
+    def test_namespace_redefined(self, env_trim):
         tmpl = env_trim.from_string("{% set ns = namespace() %}{% set ns.bar = 'hi' %}")
         exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, namespace=dict)
         assert "non-namespace object" in exc_info.value.message
- 
-    def test_namespace(self, env_trim): 
+
+    def test_namespace(self, env_trim):
         tmpl = env_trim.from_string(
             "{% set ns = namespace() %}{% set ns.bar = '42' %}{{ ns.bar }}"
         )
         assert tmpl.render() == "42"
- 
-    def test_namespace_block(self, env_trim): 
+
+    def test_namespace_block(self, env_trim):
         tmpl = env_trim.from_string(
             "{% set ns = namespace() %}{% set ns.bar %}42{% endset %}{{ ns.bar }}"
         )
         assert tmpl.render() == "42"
- 
-    def test_init_namespace(self, env_trim): 
+
+    def test_init_namespace(self, env_trim):
         tmpl = env_trim.from_string(
             "{% set ns = namespace(d, self=37) %}"
             "{% set ns.b = 42 %}"
             "{{ ns.a }}|{{ ns.self }}|{{ ns.b }}"
         )
         assert tmpl.render(d={"a": 13}) == "13|37|42"
- 
-    def test_namespace_loop(self, env_trim): 
+
+    def test_namespace_loop(self, env_trim):
         tmpl = env_trim.from_string(
             "{% set ns = namespace(found=false) %}"
             "{% for x in range(4) %}"
@@ -532,8 +532,8 @@ class TestSet(object):
         )
         assert tmpl.render(v=3) == "True"
         assert tmpl.render(v=4) == "False"
- 
-    def test_namespace_macro(self, env_trim): 
+
+    def test_namespace_macro(self, env_trim):
         tmpl = env_trim.from_string(
             "{% set ns = namespace() %}"
             "{% set ns.a = 13 %}"
@@ -544,59 +544,59 @@ class TestSet(object):
             "{{ ns.a }}|{{ ns.b }}"
         )
         assert tmpl.render() == "13|37"
- 
-    def test_block_escaping_filtered(self): 
-        env = Environment(autoescape=True) 
+
+    def test_block_escaping_filtered(self):
+        env = Environment(autoescape=True)
         tmpl = env.from_string(
             "{% set foo | trim %}<em>{{ test }}</em>    {% endset %}foo: {{ foo }}"
         )
         assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"
- 
-    def test_block_filtered(self, env_trim): 
-        tmpl = env_trim.from_string( 
+
+    def test_block_filtered(self, env_trim):
+        tmpl = env_trim.from_string(
             "{% set foo | trim | length | string %} 42    {% endset %}{{ foo }}"
         )
         assert tmpl.render() == "2"
         assert tmpl.module.foo == u"2"
- 
-    def test_block_filtered_set(self, env_trim): 
-        def _myfilter(val, arg): 
+
+    def test_block_filtered_set(self, env_trim):
+        def _myfilter(val, arg):
             assert arg == " xxx "
-            return val 
+            return val
 
         env_trim.filters["myfilter"] = _myfilter
-        tmpl = env_trim.from_string( 
-            '{% set a = " xxx " %}' 
+        tmpl = env_trim.from_string(
+            '{% set a = " xxx " %}'
             "{% set foo | myfilter(a) | trim | length | string %}"
-            ' {% set b = " yy " %} 42 {{ a }}{{ b }}   ' 
+            ' {% set b = " yy " %} 42 {{ a }}{{ b }}   '
             "{% endset %}"
             "{{ foo }}"
         )
         assert tmpl.render() == "11"
         assert tmpl.module.foo == u"11"
- 
- 
-class TestWith(object): 
-    def test_with(self, env): 
+
+
+class TestWith(object):
+    def test_with(self, env):
         tmpl = env.from_string(
             """\
-        {% with a=42, b=23 -%} 
-            {{ a }} = {{ b }} 
-        {% endwith -%} 
-            {{ a }} = {{ b }}\ 
+        {% with a=42, b=23 -%}
+            {{ a }} = {{ b }}
+        {% endwith -%}
+            {{ a }} = {{ b }}\
         """
         )
         assert [x.strip() for x in tmpl.render(a=1, b=2).splitlines()] == [
             "42 = 23",
             "1 = 2",
         ]
- 
-    def test_with_argument_scoping(self, env): 
+
+    def test_with_argument_scoping(self, env):
         tmpl = env.from_string(
             """\
-        {%- with a=1, b=2, c=b, d=e, e=5 -%} 
-            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }} 
-        {%- endwith -%} 
+        {%- with a=1, b=2, c=b, d=e, e=5 -%}
+            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
+        {%- endwith -%}
         """
         )
         assert tmpl.render(b=3, e=4) == "1|2|3|4|5"
diff --git a/contrib/python/Jinja2/py2/tests/test_debug.py b/contrib/python/Jinja2/py2/tests/test_debug.py
index 6e15d2ee9c..284b9e91a5 100644
--- a/contrib/python/Jinja2/py2/tests/test_debug.py
+++ b/contrib/python/Jinja2/py2/tests/test_debug.py
@@ -1,27 +1,27 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import pickle
 import re
 from traceback import format_exception
- 
-import pytest 
- 
+
+import pytest
+
 from jinja2 import ChoiceLoader
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2 import TemplateSyntaxError
- 
- 
-@pytest.fixture 
-def fs_env(filesystem_loader): 
+
+
+@pytest.fixture
+def fs_env(filesystem_loader):
     """returns a new environment."""
-    return Environment(loader=filesystem_loader) 
- 
- 
-class TestDebug(object): 
-    def assert_traceback_matches(self, callback, expected_tb): 
+    return Environment(loader=filesystem_loader)
+
+
+class TestDebug(object):
+    def assert_traceback_matches(self, callback, expected_tb):
         with pytest.raises(Exception) as exc_info:
-            callback() 
- 
+            callback()
+
         tb = format_exception(exc_info.type, exc_info.value, exc_info.tb)
         m = re.search(expected_tb.strip(), "".join(tb))
         assert m is not None, "Traceback did not match:\n\n%s\nexpected:\n%s" % (
@@ -29,50 +29,50 @@ class TestDebug(object):
             expected_tb,
         )
 
-    def test_runtime_error(self, fs_env): 
-        def test(): 
-            tmpl.render(fail=lambda: 1 / 0) 
+    def test_runtime_error(self, fs_env):
+        def test():
+            tmpl.render(fail=lambda: 1 / 0)
 
         tmpl = fs_env.get_template("broken.html")
         self.assert_traceback_matches(
             test,
             r"""
-  File ".*?broken.html", line 2, in (top-level template code|<module>) 
-    \{\{ fail\(\) \}\} 
-  File ".*debug?.pyc?", line \d+, in <lambda> 
-    tmpl\.render\(fail=lambda: 1 / 0\) 
-ZeroDivisionError: (int(eger)? )?division (or modulo )?by zero 
+  File ".*?broken.html", line 2, in (top-level template code|<module>)
+    \{\{ fail\(\) \}\}
+  File ".*debug?.pyc?", line \d+, in <lambda>
+    tmpl\.render\(fail=lambda: 1 / 0\)
+ZeroDivisionError: (int(eger)? )?division (or modulo )?by zero
 """,
         )
- 
-    def test_syntax_error(self, fs_env): 
+
+    def test_syntax_error(self, fs_env):
         # The trailing .*? is for PyPy 2 and 3, which don't seem to
         # clear the exception's original traceback, leaving the syntax
         # error in the middle of other compiler frames.
         self.assert_traceback_matches(
             lambda: fs_env.get_template("syntaxerror.html"),
             """(?sm)
-  File ".*?syntaxerror.html", line 4, in (template|<module>) 
+  File ".*?syntaxerror.html", line 4, in (template|<module>)
     \\{% endif %\\}.*?
 (jinja2\\.exceptions\\.)?TemplateSyntaxError: Encountered unknown tag 'endif'. Jinja \
 was looking for the following tags: 'endfor' or 'else'. The innermost block that needs \
 to be closed is 'for'.
     """,
         )
- 
-    def test_regular_syntax_error(self, fs_env): 
-        def test(): 
+
+    def test_regular_syntax_error(self, fs_env):
+        def test():
             raise TemplateSyntaxError("wtf", 42)
 
         self.assert_traceback_matches(
             test,
             r"""
-  File ".*debug.pyc?", line \d+, in test 
+  File ".*debug.pyc?", line \d+, in test
     raise TemplateSyntaxError\("wtf", 42\)
-(jinja2\.exceptions\.)?TemplateSyntaxError: wtf 
+(jinja2\.exceptions\.)?TemplateSyntaxError: wtf
   line 42""",
         )
- 
+
     def test_pickleable_syntax_error(self, fs_env):
         original = TemplateSyntaxError("bad template", 42, "test", "test.txt")
         unpickled = pickle.loads(pickle.dumps(original))
@@ -95,9 +95,9 @@ to be closed is 'for'.
 
         assert exc_info.value.source is not None
 
-    def test_local_extraction(self): 
+    def test_local_extraction(self):
         from jinja2.debug import get_template_locals
-        from jinja2.runtime import missing 
+        from jinja2.runtime import missing
 
         locals = get_template_locals(
             {
diff --git a/contrib/python/Jinja2/py2/tests/test_ext.py b/contrib/python/Jinja2/py2/tests/test_ext.py
index 9c51236441..8e4b411e1b 100644
--- a/contrib/python/Jinja2/py2/tests/test_ext.py
+++ b/contrib/python/Jinja2/py2/tests/test_ext.py
@@ -1,8 +1,8 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import re
- 
-import pytest 
- 
+
+import pytest
+
 from jinja2 import contextfunction
 from jinja2 import DictLoader
 from jinja2 import Environment
@@ -10,17 +10,17 @@ from jinja2 import nodes
 from jinja2._compat import BytesIO
 from jinja2._compat import itervalues
 from jinja2._compat import text_type
-from jinja2.exceptions import TemplateAssertionError 
-from jinja2.ext import Extension 
+from jinja2.exceptions import TemplateAssertionError
+from jinja2.ext import Extension
 from jinja2.lexer import count_newlines
 from jinja2.lexer import Token
- 
-importable_object = 23 
- 
+
+importable_object = 23
+
 _gettext_re = re.compile(r"_\((.*?)\)", re.DOTALL)
- 
- 
-i18n_templates = { 
+
+
+i18n_templates = {
     "master.html": '<title>{{ page_title|default(_("missing")) }}</title>'
     "{% block body %}{% endblock %}",
     "child.html": '{% extends "master.html" %}{% block body %}'
@@ -30,9 +30,9 @@ i18n_templates = {
     "plural2.html": "{% trans user_count=get_user_count() %}{{ user_count }}s"
     "{% pluralize %}{{ user_count }}p{% endtrans %}",
     "stringformat.html": '{{ _("User: %(num)s")|format(num=user_count) }}',
-} 
- 
-newstyle_i18n_templates = { 
+}
+
+newstyle_i18n_templates = {
     "master.html": '<title>{{ page_title|default(_("missing")) }}</title>'
     "{% block body %}{% endblock %}",
     "child.html": '{% extends "master.html" %}{% block body %}'
@@ -49,10 +49,10 @@ newstyle_i18n_templates = {
     "novars.html": "{% trans %}%(hello)s{% endtrans %}",
     "vars.html": "{% trans %}{{ foo }}%(foo)s{% endtrans %}",
     "explicitvars.html": '{% trans foo="42" %}%(foo)s{% endtrans %}',
-} 
- 
- 
-languages = { 
+}
+
+
+languages = {
     "de": {
         "missing": u"fehlend",
         "watch out": u"pass auf",
@@ -62,46 +62,46 @@ languages = {
         "User: %(count)s": u"Benutzer: %(count)s",
         "%(num)s apple": u"%(num)s Apfel",
         "%(num)s apples": u"%(num)s Äpfel",
-    } 
-} 
- 
- 
-@contextfunction 
-def gettext(context, string): 
+    }
+}
+
+
+@contextfunction
+def gettext(context, string):
     language = context.get("LANGUAGE", "en")
-    return languages.get(language, {}).get(string, string) 
- 
- 
-@contextfunction 
-def ngettext(context, s, p, n): 
+    return languages.get(language, {}).get(string, string)
+
+
+@contextfunction
+def ngettext(context, s, p, n):
     language = context.get("LANGUAGE", "en")
-    if n != 1: 
-        return languages.get(language, {}).get(p, p) 
-    return languages.get(language, {}).get(s, s) 
- 
- 
-i18n_env = Environment( 
+    if n != 1:
+        return languages.get(language, {}).get(p, p)
+    return languages.get(language, {}).get(s, s)
+
+
+i18n_env = Environment(
     loader=DictLoader(i18n_templates), extensions=["jinja2.ext.i18n"]
-) 
+)
 i18n_env.globals.update({"_": gettext, "gettext": gettext, "ngettext": ngettext})
 i18n_env_trimmed = Environment(extensions=["jinja2.ext.i18n"])
 i18n_env_trimmed.policies["ext.i18n.trimmed"] = True
 i18n_env_trimmed.globals.update(
     {"_": gettext, "gettext": gettext, "ngettext": ngettext}
 )
- 
-newstyle_i18n_env = Environment( 
+
+newstyle_i18n_env = Environment(
     loader=DictLoader(newstyle_i18n_templates), extensions=["jinja2.ext.i18n"]
-) 
-newstyle_i18n_env.install_gettext_callables(gettext, ngettext, newstyle=True) 
- 
- 
-class ExampleExtension(Extension): 
+)
+newstyle_i18n_env.install_gettext_callables(gettext, ngettext, newstyle=True)
+
+
+class ExampleExtension(Extension):
     tags = set(["test"])
-    ext_attr = 42 
+    ext_attr = 42
     context_reference_node_cls = nodes.ContextReference
- 
-    def parse(self, parser): 
+
+    def parse(self, parser):
         return nodes.Output(
             [
                 self.call_method(
@@ -115,102 +115,102 @@ class ExampleExtension(Extension):
                 )
             ]
         ).set_lineno(next(parser.stream).lineno)
- 
-    def _dump(self, sandboxed, ext_attr, imported_object, context): 
+
+    def _dump(self, sandboxed, ext_attr, imported_object, context):
         return "%s|%s|%s|%s|%s" % (
-            sandboxed, 
-            ext_attr, 
-            imported_object, 
+            sandboxed,
+            ext_attr,
+            imported_object,
             context.blocks,
             context.get("test_var"),
-        ) 
- 
- 
+        )
+
+
 class DerivedExampleExtension(ExampleExtension):
     context_reference_node_cls = nodes.DerivedContextReference
 
 
-class PreprocessorExtension(Extension): 
-    def preprocess(self, source, name, filename=None): 
+class PreprocessorExtension(Extension):
+    def preprocess(self, source, name, filename=None):
         return source.replace("[[TEST]]", "({{ foo }})")
- 
- 
-class StreamFilterExtension(Extension): 
-    def filter_stream(self, stream): 
-        for token in stream: 
+
+
+class StreamFilterExtension(Extension):
+    def filter_stream(self, stream):
+        for token in stream:
             if token.type == "data":
-                for t in self.interpolate(token): 
-                    yield t 
-            else: 
-                yield token 
- 
-    def interpolate(self, token): 
-        pos = 0 
-        end = len(token.value) 
-        lineno = token.lineno 
-        while 1: 
-            match = _gettext_re.search(token.value, pos) 
-            if match is None: 
-                break 
+                for t in self.interpolate(token):
+                    yield t
+            else:
+                yield token
+
+    def interpolate(self, token):
+        pos = 0
+        end = len(token.value)
+        lineno = token.lineno
+        while 1:
+            match = _gettext_re.search(token.value, pos)
+            if match is None:
+                break
             value = token.value[pos : match.start()]
-            if value: 
+            if value:
                 yield Token(lineno, "data", value)
-            lineno += count_newlines(token.value) 
+            lineno += count_newlines(token.value)
             yield Token(lineno, "variable_begin", None)
             yield Token(lineno, "name", "gettext")
             yield Token(lineno, "lparen", None)
             yield Token(lineno, "string", match.group(1))
             yield Token(lineno, "rparen", None)
             yield Token(lineno, "variable_end", None)
-            pos = match.end() 
-        if pos < end: 
+            pos = match.end()
+        if pos < end:
             yield Token(lineno, "data", token.value[pos:])
- 
- 
-class TestExtensions(object): 
-    def test_extend_late(self): 
-        env = Environment() 
+
+
+class TestExtensions(object):
+    def test_extend_late(self):
+        env = Environment()
         env.add_extension("jinja2.ext.autoescape")
         t = env.from_string('{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
         assert t.render() == "&lt;test&gt;"
- 
-    def test_loop_controls(self): 
+
+    def test_loop_controls(self):
         env = Environment(extensions=["jinja2.ext.loopcontrols"])
- 
+
         tmpl = env.from_string(
             """
-            {%- for item in [1, 2, 3, 4] %} 
-                {%- if item % 2 == 0 %}{% continue %}{% endif -%} 
-                {{ item }} 
+            {%- for item in [1, 2, 3, 4] %}
+                {%- if item % 2 == 0 %}{% continue %}{% endif -%}
+                {{ item }}
             {%- endfor %}"""
         )
         assert tmpl.render() == "13"
- 
+
         tmpl = env.from_string(
             """
-            {%- for item in [1, 2, 3, 4] %} 
-                {%- if item > 2 %}{% break %}{% endif -%} 
-                {{ item }} 
+            {%- for item in [1, 2, 3, 4] %}
+                {%- if item > 2 %}{% break %}{% endif -%}
+                {{ item }}
             {%- endfor %}"""
         )
         assert tmpl.render() == "12"
- 
-    def test_do(self): 
+
+    def test_do(self):
         env = Environment(extensions=["jinja2.ext.do"])
         tmpl = env.from_string(
             """
-            {%- set items = [] %} 
-            {%- for char in "foo" %} 
-                {%- do items.append(loop.index0 ~ char) %} 
+            {%- set items = [] %}
+            {%- for char in "foo" %}
+                {%- do items.append(loop.index0 ~ char) %}
             {%- endfor %}{{ items|join(', ') }}"""
         )
         assert tmpl.render() == "0f, 1o, 2o"
- 
-    def test_extension_nodes(self): 
-        env = Environment(extensions=[ExampleExtension]) 
+
+    def test_extension_nodes(self):
+        env = Environment(extensions=[ExampleExtension])
         tmpl = env.from_string("{% test %}")
         assert tmpl.render() == "False|42|23|{}|None"
- 
+
     def test_contextreference_node_passes_context(self):
         env = Environment(extensions=[ExampleExtension])
         tmpl = env.from_string('{% set test_var="test_content" %}{% test %}')
@@ -223,72 +223,72 @@ class TestExtensions(object):
         )
         assert tmpl.render() == "False|42|23|{}|test_content"
 
-    def test_identifier(self): 
+    def test_identifier(self):
         assert ExampleExtension.identifier == __name__ + ".ExampleExtension"
- 
-    def test_rebinding(self): 
-        original = Environment(extensions=[ExampleExtension]) 
-        overlay = original.overlay() 
-        for env in original, overlay: 
-            for ext in itervalues(env.extensions): 
-                assert ext.environment is env 
- 
-    def test_preprocessor_extension(self): 
-        env = Environment(extensions=[PreprocessorExtension]) 
+
+    def test_rebinding(self):
+        original = Environment(extensions=[ExampleExtension])
+        overlay = original.overlay()
+        for env in original, overlay:
+            for ext in itervalues(env.extensions):
+                assert ext.environment is env
+
+    def test_preprocessor_extension(self):
+        env = Environment(extensions=[PreprocessorExtension])
         tmpl = env.from_string("{[[TEST]]}")
         assert tmpl.render(foo=42) == "{(42)}"
- 
-    def test_streamfilter_extension(self): 
-        env = Environment(extensions=[StreamFilterExtension]) 
+
+    def test_streamfilter_extension(self):
+        env = Environment(extensions=[StreamFilterExtension])
         env.globals["gettext"] = lambda x: x.upper()
         tmpl = env.from_string("Foo _(bar) Baz")
-        out = tmpl.render() 
+        out = tmpl.render()
         assert out == "Foo BAR Baz"
- 
-    def test_extension_ordering(self): 
-        class T1(Extension): 
-            priority = 1 
- 
-        class T2(Extension): 
-            priority = 2 
-
-        env = Environment(extensions=[T1, T2]) 
-        ext = list(env.iter_extensions()) 
-        assert ext[0].__class__ is T1 
-        assert ext[1].__class__ is T2 
- 
+
+    def test_extension_ordering(self):
+        class T1(Extension):
+            priority = 1
+
+        class T2(Extension):
+            priority = 2
+
+        env = Environment(extensions=[T1, T2])
+        ext = list(env.iter_extensions())
+        assert ext[0].__class__ is T1
+        assert ext[1].__class__ is T2
+
     def test_debug(self):
         env = Environment(extensions=["jinja2.ext.debug"])
         t = env.from_string("Hello\n{% debug %}\nGoodbye")
         out = t.render()
- 
+
         for value in ("context", "cycler", "filters", "abs", "tests", "!="):
             assert "'{}'".format(value) in out
 
 
-class TestInternationalization(object): 
-    def test_trans(self): 
+class TestInternationalization(object):
+    def test_trans(self):
         tmpl = i18n_env.get_template("child.html")
         assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
- 
-    def test_trans_plural(self): 
+
+    def test_trans_plural(self):
         tmpl = i18n_env.get_template("plural.html")
         assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
         assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
- 
-    def test_trans_plural_with_functions(self): 
+
+    def test_trans_plural_with_functions(self):
         tmpl = i18n_env.get_template("plural2.html")
- 
-        def get_user_count(): 
-            get_user_count.called += 1 
-            return 1 
 
-        get_user_count.called = 0 
+        def get_user_count():
+            get_user_count.called += 1
+            return 1
+
+        get_user_count.called = 0
         assert tmpl.render(LANGUAGE="de", get_user_count=get_user_count) == "1s"
-        assert get_user_count.called == 1 
- 
-    def test_complex_plural(self): 
-        tmpl = i18n_env.from_string( 
+        assert get_user_count.called == 1
+
+    def test_complex_plural(self):
+        tmpl = i18n_env.from_string(
             "{% trans foo=42, count=2 %}{{ count }} item{% "
             "pluralize count %}{{ count }} items{% endtrans %}"
         )
@@ -298,52 +298,52 @@ class TestInternationalization(object):
             i18n_env.from_string,
             "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
         )
- 
-    def test_trans_stringformatting(self): 
+
+    def test_trans_stringformatting(self):
         tmpl = i18n_env.get_template("stringformat.html")
         assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
- 
-    def test_trimmed(self): 
-        tmpl = i18n_env.from_string( 
+
+    def test_trimmed(self):
+        tmpl = i18n_env.from_string(
             "{%- trans trimmed %}  hello\n  world  {% endtrans -%}"
         )
         assert tmpl.render() == "hello world"
- 
-    def test_trimmed_policy(self): 
+
+    def test_trimmed_policy(self):
         s = "{%- trans %}  hello\n  world  {% endtrans -%}"
-        tmpl = i18n_env.from_string(s) 
-        trimmed_tmpl = i18n_env_trimmed.from_string(s) 
+        tmpl = i18n_env.from_string(s)
+        trimmed_tmpl = i18n_env_trimmed.from_string(s)
         assert tmpl.render() == "  hello\n  world  "
         assert trimmed_tmpl.render() == "hello world"
- 
-    def test_trimmed_policy_override(self): 
-        tmpl = i18n_env_trimmed.from_string( 
+
+    def test_trimmed_policy_override(self):
+        tmpl = i18n_env_trimmed.from_string(
             "{%- trans notrimmed %}  hello\n  world  {% endtrans -%}"
         )
         assert tmpl.render() == "  hello\n  world  "
- 
-    def test_trimmed_vars(self): 
-        tmpl = i18n_env.from_string( 
+
+    def test_trimmed_vars(self):
+        tmpl = i18n_env.from_string(
             '{%- trans trimmed x="world" %}  hello\n  {{ x }} {% endtrans -%}'
         )
         assert tmpl.render() == "hello world"
- 
-    def test_trimmed_varname_trimmed(self): 
-        # unlikely variable name, but when used as a variable 
-        # it should not enable trimming 
-        tmpl = i18n_env.from_string( 
+
+    def test_trimmed_varname_trimmed(self):
+        # unlikely variable name, but when used as a variable
+        # it should not enable trimming
+        tmpl = i18n_env.from_string(
             "{%- trans trimmed = 'world' %}  hello\n  {{ trimmed }}  {% endtrans -%}"
         )
         assert tmpl.render() == "  hello\n  world  "
- 
-    def test_extract(self): 
-        from jinja2.ext import babel_extract 
+
+    def test_extract(self):
+        from jinja2.ext import babel_extract
 
         source = BytesIO(
             """
-        {{ gettext('Hello World') }} 
-        {% trans %}Hello World{% endtrans %} 
-        {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %} 
+        {{ gettext('Hello World') }}
+        {% trans %}Hello World{% endtrans %}
+        {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
         """.encode(
                 "ascii"
             )
@@ -352,17 +352,17 @@ class TestInternationalization(object):
             (2, "gettext", u"Hello World", []),
             (3, "gettext", u"Hello World", []),
             (4, "ngettext", (u"%(users)s user", u"%(users)s users", None), []),
-        ] 
- 
-    def test_extract_trimmed(self): 
-        from jinja2.ext import babel_extract 
+        ]
+
+    def test_extract_trimmed(self):
+        from jinja2.ext import babel_extract
 
         source = BytesIO(
             """
-        {{ gettext(' Hello  \n  World') }} 
-        {% trans trimmed %} Hello  \n  World{% endtrans %} 
-        {% trans trimmed %}{{ users }} \n user 
-        {%- pluralize %}{{ users }} \n users{% endtrans %} 
+        {{ gettext(' Hello  \n  World') }}
+        {% trans trimmed %} Hello  \n  World{% endtrans %}
+        {% trans trimmed %}{{ users }} \n user
+        {%- pluralize %}{{ users }} \n users{% endtrans %}
         """.encode(
                 "ascii"
             )
@@ -371,17 +371,17 @@ class TestInternationalization(object):
             (2, "gettext", u" Hello  \n  World", []),
             (4, "gettext", u"Hello World", []),
             (6, "ngettext", (u"%(users)s user", u"%(users)s users", None), []),
-        ] 
- 
-    def test_extract_trimmed_option(self): 
-        from jinja2.ext import babel_extract 
+        ]
+
+    def test_extract_trimmed_option(self):
+        from jinja2.ext import babel_extract
 
         source = BytesIO(
             """
-        {{ gettext(' Hello  \n  World') }} 
-        {% trans %} Hello  \n  World{% endtrans %} 
-        {% trans %}{{ users }} \n user 
-        {%- pluralize %}{{ users }} \n users{% endtrans %} 
+        {{ gettext(' Hello  \n  World') }}
+        {% trans %} Hello  \n  World{% endtrans %}
+        {% trans %}{{ users }} \n user
+        {%- pluralize %}{{ users }} \n users{% endtrans %}
         """.encode(
                 "ascii"
             )
@@ -391,18 +391,18 @@ class TestInternationalization(object):
             (2, "gettext", u" Hello  \n  World", []),
             (4, "gettext", u"Hello World", []),
             (6, "ngettext", (u"%(users)s user", u"%(users)s users", None), []),
-        ] 
- 
-    def test_comment_extract(self): 
-        from jinja2.ext import babel_extract 
+        ]
+
+    def test_comment_extract(self):
+        from jinja2.ext import babel_extract
 
         source = BytesIO(
             """
-        {# trans first #} 
-        {{ gettext('Hello World') }} 
-        {% trans %}Hello World{% endtrans %}{# trans second #} 
-        {#: third #} 
-        {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %} 
+        {# trans first #}
+        {{ gettext('Hello World') }}
+        {% trans %}Hello World{% endtrans %}{# trans second #}
+        {#: third #}
+        {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
         """.encode(
                 "utf-8"
             )
@@ -413,54 +413,54 @@ class TestInternationalization(object):
             (3, "gettext", u"Hello World", ["first"]),
             (4, "gettext", u"Hello World", ["second"]),
             (6, "ngettext", (u"%(users)s user", u"%(users)s users", None), ["third"]),
-        ] 
- 
- 
-class TestScope(object): 
-    def test_basic_scope_behavior(self): 
-        # This is what the old with statement compiled down to 
-        class ScopeExt(Extension): 
+        ]
+
+
+class TestScope(object):
+    def test_basic_scope_behavior(self):
+        # This is what the old with statement compiled down to
+        class ScopeExt(Extension):
             tags = set(["scope"])
- 
-            def parse(self, parser): 
-                node = nodes.Scope(lineno=next(parser.stream).lineno) 
-                assignments = [] 
+
+            def parse(self, parser):
+                node = nodes.Scope(lineno=next(parser.stream).lineno)
+                assignments = []
                 while parser.stream.current.type != "block_end":
-                    lineno = parser.stream.current.lineno 
-                    if assignments: 
+                    lineno = parser.stream.current.lineno
+                    if assignments:
                         parser.stream.expect("comma")
-                    target = parser.parse_assign_target() 
+                    target = parser.parse_assign_target()
                     parser.stream.expect("assign")
-                    expr = parser.parse_expression() 
-                    assignments.append(nodes.Assign(target, expr, lineno=lineno)) 
+                    expr = parser.parse_expression()
+                    assignments.append(nodes.Assign(target, expr, lineno=lineno))
                 node.body = assignments + list(
                     parser.parse_statements(("name:endscope",), drop_needle=True)
                 )
-                return node 
- 
-        env = Environment(extensions=[ScopeExt]) 
+                return node
+
+        env = Environment(extensions=[ScopeExt])
         tmpl = env.from_string(
             """\
-        {%- scope a=1, b=2, c=b, d=e, e=5 -%} 
-            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }} 
-        {%- endscope -%} 
+        {%- scope a=1, b=2, c=b, d=e, e=5 -%}
+            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
+        {%- endscope -%}
         """
         )
         assert tmpl.render(b=3, e=4) == "1|2|2|4|5"
- 
- 
-class TestNewstyleInternationalization(object): 
-    def test_trans(self): 
+
+
+class TestNewstyleInternationalization(object):
+    def test_trans(self):
         tmpl = newstyle_i18n_env.get_template("child.html")
         assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
- 
-    def test_trans_plural(self): 
+
+    def test_trans_plural(self):
         tmpl = newstyle_i18n_env.get_template("plural.html")
         assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
         assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
- 
-    def test_complex_plural(self): 
-        tmpl = newstyle_i18n_env.from_string( 
+
+    def test_complex_plural(self):
+        tmpl = newstyle_i18n_env.from_string(
             "{% trans foo=42, count=2 %}{{ count }} item{% "
             "pluralize count %}{{ count }} items{% endtrans %}"
         )
@@ -470,19 +470,19 @@ class TestNewstyleInternationalization(object):
             i18n_env.from_string,
             "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
         )
- 
-    def test_trans_stringformatting(self): 
+
+    def test_trans_stringformatting(self):
         tmpl = newstyle_i18n_env.get_template("stringformat.html")
         assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
- 
-    def test_newstyle_plural(self): 
+
+    def test_newstyle_plural(self):
         tmpl = newstyle_i18n_env.get_template("ngettext.html")
         assert tmpl.render(LANGUAGE="de", apples=1) == "1 Apfel"
         assert tmpl.render(LANGUAGE="de", apples=5) == u"5 Äpfel"
- 
-    def test_autoescape_support(self): 
+
+    def test_autoescape_support(self):
         env = Environment(extensions=["jinja2.ext.autoescape", "jinja2.ext.i18n"])
-        env.install_gettext_callables( 
+        env.install_gettext_callables(
             lambda x: u"<strong>Wert: %(name)s</strong>",
             lambda s, p, n: s,
             newstyle=True,
@@ -493,63 +493,63 @@ class TestNewstyleInternationalization(object):
         )
         assert t.render(ae=True) == "<strong>Wert: &lt;test&gt;</strong>"
         assert t.render(ae=False) == "<strong>Wert: <test></strong>"
- 
-    def test_autoescape_macros(self): 
+
+    def test_autoescape_macros(self):
         env = Environment(autoescape=False, extensions=["jinja2.ext.autoescape"])
-        template = ( 
+        template = (
             "{% macro m() %}<html>{% endmacro %}"
             "{% autoescape true %}{{ m() }}{% endautoescape %}"
-        ) 
+        )
         assert env.from_string(template).render() == "<html>"
- 
-    def test_num_used_twice(self): 
+
+    def test_num_used_twice(self):
         tmpl = newstyle_i18n_env.get_template("ngettext_long.html")
         assert tmpl.render(apples=5, LANGUAGE="de") == u"5 Äpfel"
- 
-    def test_num_called_num(self): 
+
+    def test_num_called_num(self):
         source = newstyle_i18n_env.compile(
             """
-            {% trans num=3 %}{{ num }} apple{% pluralize 
-            %}{{ num }} apples{% endtrans %} 
+            {% trans num=3 %}{{ num }} apple{% pluralize
+            %}{{ num }} apples{% endtrans %}
         """,
             raw=True,
         )
-        # quite hacky, but the only way to properly test that.  The idea is 
-        # that the generated code does not pass num twice (although that 
-        # would work) for better performance.  This only works on the 
-        # newstyle gettext of course 
+        # quite hacky, but the only way to properly test that.  The idea is
+        # that the generated code does not pass num twice (although that
+        # would work) for better performance.  This only works on the
+        # newstyle gettext of course
         assert (
             re.search(r"u?'\%\(num\)s apple', u?'\%\(num\)s " r"apples', 3", source)
             is not None
         )
- 
-    def test_trans_vars(self): 
+
+    def test_trans_vars(self):
         t1 = newstyle_i18n_env.get_template("transvars1.html")
         t2 = newstyle_i18n_env.get_template("transvars2.html")
         t3 = newstyle_i18n_env.get_template("transvars3.html")
         assert t1.render(num=1, LANGUAGE="de") == "Benutzer: 1"
         assert t2.render(count=23, LANGUAGE="de") == "Benutzer: 23"
         assert t3.render(num=42, LANGUAGE="de") == "Benutzer: 42"
- 
-    def test_novars_vars_escaping(self): 
+
+    def test_novars_vars_escaping(self):
         t = newstyle_i18n_env.get_template("novars.html")
         assert t.render() == "%(hello)s"
         t = newstyle_i18n_env.get_template("vars.html")
         assert t.render(foo="42") == "42%(foo)s"
         t = newstyle_i18n_env.get_template("explicitvars.html")
         assert t.render() == "%(foo)s"
- 
- 
-class TestAutoEscape(object): 
-    def test_scoped_setting(self): 
+
+
+class TestAutoEscape(object):
+    def test_scoped_setting(self):
         env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
         tmpl = env.from_string(
             """
-            {{ "<HelloWorld>" }} 
-            {% autoescape false %} 
-                {{ "<HelloWorld>" }} 
-            {% endautoescape %} 
-            {{ "<HelloWorld>" }} 
+            {{ "<HelloWorld>" }}
+            {% autoescape false %}
+                {{ "<HelloWorld>" }}
+            {% endautoescape %}
+            {{ "<HelloWorld>" }}
         """
         )
         assert tmpl.render().split() == [
@@ -557,15 +557,15 @@ class TestAutoEscape(object):
             u"<HelloWorld>",
             u"&lt;HelloWorld&gt;",
         ]
- 
+
         env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=False)
         tmpl = env.from_string(
             """
-            {{ "<HelloWorld>" }} 
-            {% autoescape true %} 
-                {{ "<HelloWorld>" }} 
-            {% endautoescape %} 
-            {{ "<HelloWorld>" }} 
+            {{ "<HelloWorld>" }}
+            {% autoescape true %}
+                {{ "<HelloWorld>" }}
+            {% endautoescape %}
+            {{ "<HelloWorld>" }}
         """
         )
         assert tmpl.render().split() == [
@@ -573,83 +573,83 @@ class TestAutoEscape(object):
             u"&lt;HelloWorld&gt;",
             u"<HelloWorld>",
         ]
- 
-    def test_nonvolatile(self): 
+
+    def test_nonvolatile(self):
         env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
-        tmpl = env.from_string('{{ {"foo": "<test>"}|xmlattr|escape }}') 
-        assert tmpl.render() == ' foo="&lt;test&gt;"' 
+        tmpl = env.from_string('{{ {"foo": "<test>"}|xmlattr|escape }}')
+        assert tmpl.render() == ' foo="&lt;test&gt;"'
         tmpl = env.from_string(
             '{% autoescape false %}{{ {"foo": "<test>"}'
             "|xmlattr|escape }}{% endautoescape %}"
         )
         assert tmpl.render() == " foo=&#34;&amp;lt;test&amp;gt;&#34;"
- 
-    def test_volatile(self): 
+
+    def test_volatile(self):
         env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
         tmpl = env.from_string(
             '{% autoescape foo %}{{ {"foo": "<test>"}'
             "|xmlattr|escape }}{% endautoescape %}"
         )
         assert tmpl.render(foo=False) == " foo=&#34;&amp;lt;test&amp;gt;&#34;"
-        assert tmpl.render(foo=True) == ' foo="&lt;test&gt;"' 
- 
-    def test_scoping(self): 
+        assert tmpl.render(foo=True) == ' foo="&lt;test&gt;"'
+
+    def test_scoping(self):
         env = Environment(extensions=["jinja2.ext.autoescape"])
-        tmpl = env.from_string( 
-            '{% autoescape true %}{% set x = "<x>" %}{{ x }}' 
+        tmpl = env.from_string(
+            '{% autoescape true %}{% set x = "<x>" %}{{ x }}'
             '{% endautoescape %}{{ x }}{{ "<y>" }}'
         )
         assert tmpl.render(x=1) == "&lt;x&gt;1<y>"
- 
-    def test_volatile_scoping(self): 
+
+    def test_volatile_scoping(self):
         env = Environment(extensions=["jinja2.ext.autoescape"])
         tmplsource = """
-        {% autoescape val %} 
-            {% macro foo(x) %} 
-                [{{ x }}] 
-            {% endmacro %} 
-            {{ foo().__class__.__name__ }} 
-        {% endautoescape %} 
-        {{ '<testing>' }} 
+        {% autoescape val %}
+            {% macro foo(x) %}
+                [{{ x }}]
+            {% endmacro %}
+            {{ foo().__class__.__name__ }}
+        {% endautoescape %}
+        {{ '<testing>' }}
         """
-        tmpl = env.from_string(tmplsource) 
+        tmpl = env.from_string(tmplsource)
         assert tmpl.render(val=True).split()[0] == "Markup"
-        assert tmpl.render(val=False).split()[0] == text_type.__name__ 
- 
-        # looking at the source we should see <testing> there in raw 
-        # (and then escaped as well) 
+        assert tmpl.render(val=False).split()[0] == text_type.__name__
+
+        # looking at the source we should see <testing> there in raw
+        # (and then escaped as well)
         env = Environment(extensions=["jinja2.ext.autoescape"])
-        pysource = env.compile(tmplsource, raw=True) 
+        pysource = env.compile(tmplsource, raw=True)
         assert "<testing>\\n" in pysource
- 
+
         env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
-        pysource = env.compile(tmplsource, raw=True) 
+        pysource = env.compile(tmplsource, raw=True)
         assert "&lt;testing&gt;\\n" in pysource
- 
-    def test_overlay_scopes(self): 
-        class MagicScopeExtension(Extension): 
+
+    def test_overlay_scopes(self):
+        class MagicScopeExtension(Extension):
             tags = set(["overlay"])
 
-            def parse(self, parser): 
-                node = nodes.OverlayScope(lineno=next(parser.stream).lineno) 
+            def parse(self, parser):
+                node = nodes.OverlayScope(lineno=next(parser.stream).lineno)
                 node.body = list(
                     parser.parse_statements(("name:endoverlay",), drop_needle=True)
                 )
                 node.context = self.call_method("get_scope")
-                return node 
+                return node
 
-            def get_scope(self): 
+            def get_scope(self):
                 return {"x": [1, 2, 3]}
- 
-        env = Environment(extensions=[MagicScopeExtension]) 
- 
+
+        env = Environment(extensions=[MagicScopeExtension])
+
         tmpl = env.from_string(
             """
-            {{- x }}|{% set z = 99 %} 
-            {%- overlay %} 
-                {{- y }}|{{ z }}|{% for item in x %}[{{ item }}]{% endfor %} 
-            {%- endoverlay %}| 
-            {{- x -}} 
+            {{- x }}|{% set z = 99 %}
+            {%- overlay %}
+                {{- y }}|{{ z }}|{% for item in x %}[{{ item }}]{% endfor %}
+            {%- endoverlay %}|
+            {{- x -}}
         """
         )
         assert tmpl.render(x=42, y=23) == "42|23|99|[1][2][3]|42"
diff --git a/contrib/python/Jinja2/py2/tests/test_features.py b/contrib/python/Jinja2/py2/tests/test_features.py
index d65832923e..34b6f200de 100644
--- a/contrib/python/Jinja2/py2/tests/test_features.py
+++ b/contrib/python/Jinja2/py2/tests/test_features.py
@@ -1,42 +1,42 @@
-import sys 
+import sys
+
+import pytest
 
-import pytest 
- 
 from jinja2 import contextfilter
 from jinja2 import Environment
 from jinja2 import Template
 from jinja2._compat import text_type
- 
- 
+
+
 @pytest.mark.skipif(sys.version_info < (3, 5), reason="Requires 3.5 or later")
-def test_generator_stop(): 
-    class X(object): 
-        def __getattr__(self, name): 
-            raise StopIteration() 
- 
+def test_generator_stop():
+    class X(object):
+        def __getattr__(self, name):
+            raise StopIteration()
+
     t = Template("a{{ bad.bar() }}b")
-    with pytest.raises(RuntimeError): 
-        t.render(bad=X()) 
- 
- 
+    with pytest.raises(RuntimeError):
+        t.render(bad=X())
+
+
 @pytest.mark.skipif(sys.version_info[0] > 2, reason="Feature only supported on 2.x")
-def test_ascii_str(): 
-    @contextfilter 
-    def assert_func(context, value): 
+def test_ascii_str():
+    @contextfilter
+    def assert_func(context, value):
         assert type(value) is context["expected_type"]
- 
-    env = Environment() 
+
+    env = Environment()
     env.filters["assert"] = assert_func
- 
+
     env.policies["compiler.ascii_str"] = False
-    t = env.from_string('{{ "foo"|assert }}') 
+    t = env.from_string('{{ "foo"|assert }}')
     t.render(expected_type=text_type)
- 
+
     env.policies["compiler.ascii_str"] = True
-    t = env.from_string('{{ "foo"|assert }}') 
-    t.render(expected_type=str) 
- 
-    for val in True, False: 
+    t = env.from_string('{{ "foo"|assert }}')
+    t.render(expected_type=str)
+
+    for val in True, False:
         env.policies["compiler.ascii_str"] = val
-        t = env.from_string(u'{{ "\N{SNOWMAN}"|assert }}') 
+        t = env.from_string(u'{{ "\N{SNOWMAN}"|assert }}')
         t.render(expected_type=text_type)
diff --git a/contrib/python/Jinja2/py2/tests/test_filters.py b/contrib/python/Jinja2/py2/tests/test_filters.py
index ae37b1a163..388c346212 100644
--- a/contrib/python/Jinja2/py2/tests/test_filters.py
+++ b/contrib/python/Jinja2/py2/tests/test_filters.py
@@ -1,26 +1,26 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import random
 from collections import namedtuple
- 
-import pytest 
- 
+
+import pytest
+
 from jinja2 import Environment
 from jinja2 import Markup
 from jinja2 import StrictUndefined
 from jinja2 import UndefinedError
 from jinja2._compat import implements_to_string
 from jinja2._compat import text_type
- 
-
-@implements_to_string 
-class Magic(object): 
-    def __init__(self, value): 
-        self.value = value 
- 
-    def __str__(self): 
-        return text_type(self.value) 
- 
- 
+
+
+@implements_to_string
+class Magic(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return text_type(self.value)
+
+
 @implements_to_string
 class Magic2(object):
     def __init__(self, value1, value2):
@@ -31,26 +31,26 @@ class Magic2(object):
         return u"(%s,%s)" % (text_type(self.value1), text_type(self.value2))
 
 
-class TestFilter(object): 
-    def test_filter_calling(self, env): 
+class TestFilter(object):
+    def test_filter_calling(self, env):
         rv = env.call_filter("sum", [1, 2, 3])
-        assert rv == 6 
- 
-    def test_capitalize(self, env): 
-        tmpl = env.from_string('{{ "foo bar"|capitalize }}') 
+        assert rv == 6
+
+    def test_capitalize(self, env):
+        tmpl = env.from_string('{{ "foo bar"|capitalize }}')
         assert tmpl.render() == "Foo bar"
- 
-    def test_center(self, env): 
-        tmpl = env.from_string('{{ "foo"|center(9) }}') 
+
+    def test_center(self, env):
+        tmpl = env.from_string('{{ "foo"|center(9) }}')
         assert tmpl.render() == "   foo   "
- 
-    def test_default(self, env): 
-        tmpl = env.from_string( 
-            "{{ missing|default('no') }}|{{ false|default('no') }}|" 
-            "{{ false|default('no', true) }}|{{ given|default('no') }}" 
-        ) 
+
+    def test_default(self, env):
+        tmpl = env.from_string(
+            "{{ missing|default('no') }}|{{ false|default('no') }}|"
+            "{{ false|default('no', true) }}|{{ given|default('no') }}"
+        )
         assert tmpl.render(given="yes") == "no|False|no|yes"
- 
+
     @pytest.mark.parametrize(
         "args,expect",
         (
@@ -60,32 +60,32 @@ class TestFilter(object):
             ("reverse=true", "[('c', 2), ('b', 1), ('AB', 3), ('aa', 0)]"),
         ),
     )
-    def test_dictsort(self, env, args, expect): 
+    def test_dictsort(self, env, args, expect):
         t = env.from_string("{{{{ foo|dictsort({args}) }}}}".format(args=args))
-        out = t.render(foo={"aa": 0, "b": 1, "c": 2, "AB": 3}) 
-        assert out == expect 
- 
-    def test_batch(self, env): 
+        out = t.render(foo={"aa": 0, "b": 1, "c": 2, "AB": 3})
+        assert out == expect
+
+    def test_batch(self, env):
         tmpl = env.from_string("{{ foo|batch(3)|list }}|{{ foo|batch(3, 'X')|list }}")
-        out = tmpl.render(foo=list(range(10))) 
+        out = tmpl.render(foo=list(range(10)))
         assert out == (
             "[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]|"
             "[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 'X', 'X']]"
         )
- 
-    def test_slice(self, env): 
+
+    def test_slice(self, env):
         tmpl = env.from_string("{{ foo|slice(3)|list }}|{{ foo|slice(3, 'X')|list }}")
-        out = tmpl.render(foo=list(range(10))) 
+        out = tmpl.render(foo=list(range(10)))
         assert out == (
             "[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|"
             "[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]"
         )
- 
-    def test_escape(self, env): 
+
+    def test_escape(self, env):
         tmpl = env.from_string("""{{ '<">&'|escape }}""")
-        out = tmpl.render() 
+        out = tmpl.render()
         assert out == "&lt;&#34;&gt;&amp;"
- 
+
     @pytest.mark.parametrize(
         ("chars", "expect"), [(None, "..stays.."), (".", "  ..stays"), (" .", "stays")]
     )
@@ -94,7 +94,7 @@ class TestFilter(object):
         out = tmpl.render(foo="  ..stays..", chars=chars)
         assert out == expect
 
-    def test_striptags(self, env): 
+    def test_striptags(self, env):
         tmpl = env.from_string("""{{ foo|striptags }}""")
         out = tmpl.render(
             foo='  <p>just a small   \n <a href="#">'
@@ -102,9 +102,9 @@ class TestFilter(object):
             "<!-- <p>and some commented stuff</p> -->"
         )
         assert out == "just a small example link to a webpage"
- 
-    def test_filesizeformat(self, env): 
-        tmpl = env.from_string( 
+
+    def test_filesizeformat(self, env):
+        tmpl = env.from_string(
             "{{ 100|filesizeformat }}|"
             "{{ 1000|filesizeformat }}|"
             "{{ 1000000|filesizeformat }}|"
@@ -115,15 +115,15 @@ class TestFilter(object):
             "{{ 1000000|filesizeformat(true) }}|"
             "{{ 1000000000|filesizeformat(true) }}|"
             "{{ 1000000000000|filesizeformat(true) }}"
-        ) 
-        out = tmpl.render() 
-        assert out == ( 
+        )
+        out = tmpl.render()
+        assert out == (
             "100 Bytes|1.0 kB|1.0 MB|1.0 GB|1.0 TB|100 Bytes|"
             "1000 Bytes|976.6 KiB|953.7 MiB|931.3 GiB"
-        ) 
- 
-    def test_filesizeformat_issue59(self, env): 
-        tmpl = env.from_string( 
+        )
+
+    def test_filesizeformat_issue59(self, env):
+        tmpl = env.from_string(
             "{{ 300|filesizeformat }}|"
             "{{ 3000|filesizeformat }}|"
             "{{ 3000000|filesizeformat }}|"
@@ -132,33 +132,33 @@ class TestFilter(object):
             "{{ 300|filesizeformat(true) }}|"
             "{{ 3000|filesizeformat(true) }}|"
             "{{ 3000000|filesizeformat(true) }}"
-        ) 
-        out = tmpl.render() 
-        assert out == ( 
+        )
+        out = tmpl.render()
+        assert out == (
             "300 Bytes|3.0 kB|3.0 MB|3.0 GB|3.0 TB|300 Bytes|2.9 KiB|2.9 MiB"
-        ) 
- 
-    def test_first(self, env): 
+        )
+
+    def test_first(self, env):
         tmpl = env.from_string("{{ foo|first }}")
-        out = tmpl.render(foo=list(range(10))) 
+        out = tmpl.render(foo=list(range(10)))
         assert out == "0"
- 
+
     @pytest.mark.parametrize(
         ("value", "expect"), (("42", "42.0"), ("abc", "0.0"), ("32.32", "32.32"),)
     )
     def test_float(self, env, value, expect):
         t = env.from_string("{{ '%s'|float }}" % value)
         assert t.render() == expect
- 
+
     def test_float_default(self, env):
         t = env.from_string("{{ value|float(default=1.0) }}")
         assert t.render(value="abc") == "1.0"
 
-    def test_format(self, env): 
+    def test_format(self, env):
         tmpl = env.from_string("""{{ "%s|%s"|format("a", "b") }}""")
-        out = tmpl.render() 
+        out = tmpl.render()
         assert out == "a|b"
- 
+
     @staticmethod
     def _test_indent_multiline_template(env, markup=False):
         text = "\n".join(["", "foo bar", '"baz"', ""])
@@ -173,21 +173,21 @@ class TestFilter(object):
         t = env.from_string("{{ foo|indent(2, true, true) }}")
         assert t.render(foo=text) == '  \n  foo bar\n  "baz"\n  '
 
-    def test_indent(self, env): 
+    def test_indent(self, env):
         self._test_indent_multiline_template(env)
-        t = env.from_string('{{ "jinja"|indent }}') 
+        t = env.from_string('{{ "jinja"|indent }}')
         assert t.render() == "jinja"
-        t = env.from_string('{{ "jinja"|indent(first=true) }}') 
+        t = env.from_string('{{ "jinja"|indent(first=true) }}')
         assert t.render() == "    jinja"
-        t = env.from_string('{{ "jinja"|indent(blank=true) }}') 
+        t = env.from_string('{{ "jinja"|indent(blank=true) }}')
         assert t.render() == "jinja"
- 
+
     def test_indent_markup_input(self, env):
         """
         Tests cases where the filter input is a Markup type
         """
         self._test_indent_multiline_template(env, markup=True)
- 
+
     @pytest.mark.parametrize(
         ("value", "expect"),
         (
@@ -214,185 +214,185 @@ class TestFilter(object):
         assert t.render(value="abc") == "1"
 
     def test_int_special_method(self, env):
-        class IntIsh(object): 
-            def __int__(self): 
-                return 42 
- 
+        class IntIsh(object):
+            def __int__(self):
+                return 42
+
         t = env.from_string("{{ value|int }}")
         assert t.render(value=IntIsh()) == "42"
- 
-    def test_join(self, env): 
-        tmpl = env.from_string('{{ [1, 2, 3]|join("|") }}') 
-        out = tmpl.render() 
+
+    def test_join(self, env):
+        tmpl = env.from_string('{{ [1, 2, 3]|join("|") }}')
+        out = tmpl.render()
         assert out == "1|2|3"
- 
-        env2 = Environment(autoescape=True) 
+
+        env2 = Environment(autoescape=True)
         tmpl = env2.from_string('{{ ["<foo>", "<span>foo</span>"|safe]|join }}')
         assert tmpl.render() == "&lt;foo&gt;<span>foo</span>"
- 
-    def test_join_attribute(self, env): 
+
+    def test_join_attribute(self, env):
         User = namedtuple("User", "username")
         tmpl = env.from_string("""{{ users|join(', ', 'username') }}""")
         assert tmpl.render(users=map(User, ["foo", "bar"])) == "foo, bar"
- 
-    def test_last(self, env): 
+
+    def test_last(self, env):
         tmpl = env.from_string("""{{ foo|last }}""")
-        out = tmpl.render(foo=list(range(10))) 
+        out = tmpl.render(foo=list(range(10)))
         assert out == "9"
- 
-    def test_length(self, env): 
+
+    def test_length(self, env):
         tmpl = env.from_string("""{{ "hello world"|length }}""")
-        out = tmpl.render() 
+        out = tmpl.render()
         assert out == "11"
- 
-    def test_lower(self, env): 
+
+    def test_lower(self, env):
         tmpl = env.from_string("""{{ "FOO"|lower }}""")
-        out = tmpl.render() 
+        out = tmpl.render()
         assert out == "foo"
- 
-    def test_pprint(self, env): 
-        from pprint import pformat 
+
+    def test_pprint(self, env):
+        from pprint import pformat
 
         tmpl = env.from_string("""{{ data|pprint }}""")
-        data = list(range(1000)) 
-        assert tmpl.render(data=data) == pformat(data) 
- 
-    def test_random(self, env, request): 
-        # restore the random state when the test ends 
-        state = random.getstate() 
-        request.addfinalizer(lambda: random.setstate(state)) 
-        # generate the random values from a known seed 
+        data = list(range(1000))
+        assert tmpl.render(data=data) == pformat(data)
+
+    def test_random(self, env, request):
+        # restore the random state when the test ends
+        state = random.getstate()
+        request.addfinalizer(lambda: random.setstate(state))
+        # generate the random values from a known seed
         random.seed("jinja")
         expected = [random.choice("1234567890") for _ in range(10)]
- 
-        # check that the random sequence is generated again by a template 
-        # ensures that filter result is not constant folded 
+
+        # check that the random sequence is generated again by a template
+        # ensures that filter result is not constant folded
         random.seed("jinja")
-        t = env.from_string('{{ "1234567890"|random }}') 
- 
-        for value in expected: 
-            assert t.render() == value 
- 
-    def test_reverse(self, env): 
+        t = env.from_string('{{ "1234567890"|random }}')
+
+        for value in expected:
+            assert t.render() == value
+
+    def test_reverse(self, env):
         tmpl = env.from_string(
             "{{ 'foobar'|reverse|join }}|{{ [1, 2, 3]|reverse|list }}"
         )
         assert tmpl.render() == "raboof|[3, 2, 1]"
- 
-    def test_string(self, env): 
-        x = [1, 2, 3, 4, 5] 
+
+    def test_string(self, env):
+        x = [1, 2, 3, 4, 5]
         tmpl = env.from_string("""{{ obj|string }}""")
-        assert tmpl.render(obj=x) == text_type(x) 
- 
-    def test_title(self, env): 
+        assert tmpl.render(obj=x) == text_type(x)
+
+    def test_title(self, env):
         tmpl = env.from_string("""{{ "foo bar"|title }}""")
-        assert tmpl.render() == "Foo Bar" 
+        assert tmpl.render() == "Foo Bar"
         tmpl = env.from_string("""{{ "foo's bar"|title }}""")
-        assert tmpl.render() == "Foo's Bar" 
+        assert tmpl.render() == "Foo's Bar"
         tmpl = env.from_string("""{{ "foo   bar"|title }}""")
-        assert tmpl.render() == "Foo   Bar" 
+        assert tmpl.render() == "Foo   Bar"
         tmpl = env.from_string("""{{ "f bar f"|title }}""")
-        assert tmpl.render() == "F Bar F" 
+        assert tmpl.render() == "F Bar F"
         tmpl = env.from_string("""{{ "foo-bar"|title }}""")
-        assert tmpl.render() == "Foo-Bar" 
+        assert tmpl.render() == "Foo-Bar"
         tmpl = env.from_string("""{{ "foo\tbar"|title }}""")
-        assert tmpl.render() == "Foo\tBar" 
+        assert tmpl.render() == "Foo\tBar"
         tmpl = env.from_string("""{{ "FOO\tBAR"|title }}""")
-        assert tmpl.render() == "Foo\tBar" 
+        assert tmpl.render() == "Foo\tBar"
         tmpl = env.from_string("""{{ "foo (bar)"|title }}""")
-        assert tmpl.render() == "Foo (Bar)" 
+        assert tmpl.render() == "Foo (Bar)"
         tmpl = env.from_string("""{{ "foo {bar}"|title }}""")
-        assert tmpl.render() == "Foo {Bar}" 
+        assert tmpl.render() == "Foo {Bar}"
         tmpl = env.from_string("""{{ "foo [bar]"|title }}""")
-        assert tmpl.render() == "Foo [Bar]" 
+        assert tmpl.render() == "Foo [Bar]"
         tmpl = env.from_string("""{{ "foo <bar>"|title }}""")
-        assert tmpl.render() == "Foo <Bar>" 
- 
-        class Foo: 
-            def __str__(self): 
+        assert tmpl.render() == "Foo <Bar>"
+
+        class Foo:
+            def __str__(self):
                 return "foo-bar"
- 
+
         tmpl = env.from_string("""{{ data|title }}""")
-        out = tmpl.render(data=Foo()) 
+        out = tmpl.render(data=Foo())
         assert out == "Foo-Bar"
- 
-    def test_truncate(self, env): 
-        tmpl = env.from_string( 
-            '{{ data|truncate(15, true, ">>>") }}|' 
-            '{{ data|truncate(15, false, ">>>") }}|' 
+
+    def test_truncate(self, env):
+        tmpl = env.from_string(
+            '{{ data|truncate(15, true, ">>>") }}|'
+            '{{ data|truncate(15, false, ">>>") }}|'
             "{{ smalldata|truncate(15) }}"
-        ) 
+        )
         out = tmpl.render(data="foobar baz bar" * 1000, smalldata="foobar baz bar")
         msg = "Current output: %s" % out
         assert out == "foobar baz b>>>|foobar baz>>>|foobar baz bar", msg
- 
-    def test_truncate_very_short(self, env): 
-        tmpl = env.from_string( 
+
+    def test_truncate_very_short(self, env):
+        tmpl = env.from_string(
             '{{ "foo bar baz"|truncate(9) }}|{{ "foo bar baz"|truncate(9, true) }}'
-        ) 
-        out = tmpl.render() 
+        )
+        out = tmpl.render()
         assert out == "foo bar baz|foo bar baz", out
- 
-    def test_truncate_end_length(self, env): 
-        tmpl = env.from_string('{{ "Joel is a slug"|truncate(7, true) }}') 
-        out = tmpl.render() 
+
+    def test_truncate_end_length(self, env):
+        tmpl = env.from_string('{{ "Joel is a slug"|truncate(7, true) }}')
+        out = tmpl.render()
         assert out == "Joel...", "Current output: %s" % out
- 
-    def test_upper(self, env): 
-        tmpl = env.from_string('{{ "foo"|upper }}') 
+
+    def test_upper(self, env):
+        tmpl = env.from_string('{{ "foo"|upper }}')
         assert tmpl.render() == "FOO"
- 
-    def test_urlize(self, env): 
+
+    def test_urlize(self, env):
         tmpl = env.from_string('{{ "foo http://www.example.com/ bar"|urlize }}')
-        assert tmpl.render() == ( 
-            'foo <a href="http://www.example.com/" rel="noopener">' 
+        assert tmpl.render() == (
+            'foo <a href="http://www.example.com/" rel="noopener">'
             "http://www.example.com/</a> bar"
-        ) 
- 
-    def test_urlize_rel_policy(self): 
-        env = Environment() 
+        )
+
+    def test_urlize_rel_policy(self):
+        env = Environment()
         env.policies["urlize.rel"] = None
         tmpl = env.from_string('{{ "foo http://www.example.com/ bar"|urlize }}')
-        assert tmpl.render() == ( 
+        assert tmpl.render() == (
             'foo <a href="http://www.example.com/">http://www.example.com/</a> bar'
-        ) 
- 
-    def test_urlize_target_parameter(self, env): 
-        tmpl = env.from_string( 
-            '{{ "foo http://www.example.com/ bar"|urlize(target="_blank") }}' 
-        ) 
+        )
+
+    def test_urlize_target_parameter(self, env):
+        tmpl = env.from_string(
+            '{{ "foo http://www.example.com/ bar"|urlize(target="_blank") }}'
+        )
         assert (
             tmpl.render()
             == 'foo <a href="http://www.example.com/" rel="noopener" target="_blank">'
             "http://www.example.com/</a> bar"
         )
- 
-    def test_wordcount(self, env): 
-        tmpl = env.from_string('{{ "foo bar baz"|wordcount }}') 
+
+    def test_wordcount(self, env):
+        tmpl = env.from_string('{{ "foo bar baz"|wordcount }}')
         assert tmpl.render() == "3"
- 
+
         strict_env = Environment(undefined=StrictUndefined)
         t = strict_env.from_string("{{ s|wordcount }}")
         with pytest.raises(UndefinedError):
             t.render()
 
-    def test_block(self, env): 
+    def test_block(self, env):
         tmpl = env.from_string("{% filter lower|escape %}<HEHE>{% endfilter %}")
         assert tmpl.render() == "&lt;hehe&gt;"
- 
-    def test_chaining(self, env): 
+
+    def test_chaining(self, env):
         tmpl = env.from_string("""{{ ['<foo>', '<bar>']|first|upper|escape }}""")
         assert tmpl.render() == "&lt;FOO&gt;"
- 
-    def test_sum(self, env): 
+
+    def test_sum(self, env):
         tmpl = env.from_string("""{{ [1, 2, 3, 4, 5, 6]|sum }}""")
         assert tmpl.render() == "21"
- 
-    def test_sum_attributes(self, env): 
+
+    def test_sum_attributes(self, env):
         tmpl = env.from_string("""{{ values|sum('value') }}""")
         assert tmpl.render(values=[{"value": 23}, {"value": 1}, {"value": 18}]) == "42"
- 
-    def test_sum_attributes_nested(self, env): 
+
+    def test_sum_attributes_nested(self, env):
         tmpl = env.from_string("""{{ values|sum('real.value') }}""")
         assert (
             tmpl.render(
@@ -404,58 +404,58 @@ class TestFilter(object):
             )
             == "42"
         )
- 
-    def test_sum_attributes_tuple(self, env): 
+
+    def test_sum_attributes_tuple(self, env):
         tmpl = env.from_string("""{{ values.items()|sum('1') }}""")
         assert tmpl.render(values={"foo": 23, "bar": 1, "baz": 18}) == "42"
- 
-    def test_abs(self, env): 
+
+    def test_abs(self, env):
         tmpl = env.from_string("""{{ -1|abs }}|{{ 1|abs }}""")
         assert tmpl.render() == "1|1", tmpl.render()
- 
-    def test_round_positive(self, env): 
+
+    def test_round_positive(self, env):
         tmpl = env.from_string(
             "{{ 2.7|round }}|{{ 2.1|round }}|"
             "{{ 2.1234|round(3, 'floor') }}|"
             "{{ 2.1|round(0, 'ceil') }}"
         )
         assert tmpl.render() == "3.0|2.0|2.123|3.0", tmpl.render()
- 
-    def test_round_negative(self, env): 
+
+    def test_round_negative(self, env):
         tmpl = env.from_string(
             "{{ 21.3|round(-1)}}|"
             "{{ 21.3|round(-1, 'ceil')}}|"
             "{{ 21.3|round(-1, 'floor')}}"
         )
         assert tmpl.render() == "20.0|30.0|20.0", tmpl.render()
- 
-    def test_xmlattr(self, env): 
-        tmpl = env.from_string( 
-            "{{ {'foo': 42, 'bar': 23, 'fish': none, " 
+
+    def test_xmlattr(self, env):
+        tmpl = env.from_string(
+            "{{ {'foo': 42, 'bar': 23, 'fish': none, "
             "'spam': missing, 'blub:blub': '<?>'}|xmlattr }}"
         )
-        out = tmpl.render().split() 
-        assert len(out) == 3 
-        assert 'foo="42"' in out 
-        assert 'bar="23"' in out 
-        assert 'blub:blub="&lt;?&gt;"' in out 
- 
-    def test_sort1(self, env): 
+        out = tmpl.render().split()
+        assert len(out) == 3
+        assert 'foo="42"' in out
+        assert 'bar="23"' in out
+        assert 'blub:blub="&lt;?&gt;"' in out
+
+    def test_sort1(self, env):
         tmpl = env.from_string("{{ [2, 3, 1]|sort }}|{{ [2, 3, 1]|sort(true) }}")
         assert tmpl.render() == "[1, 2, 3]|[3, 2, 1]"
- 
-    def test_sort2(self, env): 
-        tmpl = env.from_string('{{ "".join(["c", "A", "b", "D"]|sort) }}') 
+
+    def test_sort2(self, env):
+        tmpl = env.from_string('{{ "".join(["c", "A", "b", "D"]|sort) }}')
         assert tmpl.render() == "AbcD"
- 
-    def test_sort3(self, env): 
+
+    def test_sort3(self, env):
         tmpl = env.from_string("""{{ ['foo', 'Bar', 'blah']|sort }}""")
-        assert tmpl.render() == "['Bar', 'blah', 'foo']" 
- 
-    def test_sort4(self, env): 
+        assert tmpl.render() == "['Bar', 'blah', 'foo']"
+
+    def test_sort4(self, env):
         tmpl = env.from_string("""{{ items|sort(attribute='value')|join }}""")
         assert tmpl.render(items=map(Magic, [3, 2, 4, 1])) == "1234"
- 
+
     def test_sort5(self, env):
         tmpl = env.from_string("""{{ items|sort(attribute='value.0')|join }}""")
         assert tmpl.render(items=map(Magic, [[3], [2], [4], [1]])) == "[1][2][3][4]"
@@ -496,18 +496,18 @@ class TestFilter(object):
             == "([2],[1])([2],[2])([2],[5])([3],[1])"
         )
 
-    def test_unique(self, env): 
-        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique) }}') 
-        assert t.render() == "bA" 
- 
-    def test_unique_case_sensitive(self, env): 
-        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique(true)) }}') 
-        assert t.render() == "bAa" 
- 
-    def test_unique_attribute(self, env): 
-        t = env.from_string("{{ items|unique(attribute='value')|join }}") 
+    def test_unique(self, env):
+        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique) }}')
+        assert t.render() == "bA"
+
+    def test_unique_case_sensitive(self, env):
+        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique(true)) }}')
+        assert t.render() == "bAa"
+
+    def test_unique_attribute(self, env):
+        t = env.from_string("{{ items|unique(attribute='value')|join }}")
         assert t.render(items=map(Magic, [3, 2, 4, 1, 2])) == "3241"
- 
+
     @pytest.mark.parametrize(
         "source,expect",
         (
@@ -519,86 +519,86 @@ class TestFilter(object):
             ("{{ []|max }}", ""),
         ),
     )
-    def test_min_max(self, env, source, expect): 
-        t = env.from_string(source) 
-        assert t.render() == expect 
- 
+    def test_min_max(self, env, source, expect):
+        t = env.from_string(source)
+        assert t.render() == expect
+
     @pytest.mark.parametrize("name,expect", (("min", "1"), ("max", "9"),))
-    def test_min_max_attribute(self, env, name, expect): 
+    def test_min_max_attribute(self, env, name, expect):
         t = env.from_string("{{ items|" + name + '(attribute="value") }}')
-        assert t.render(items=map(Magic, [5, 1, 9])) == expect 
- 
-    def test_groupby(self, env): 
+        assert t.render(items=map(Magic, [5, 1, 9])) == expect
+
+    def test_groupby(self, env):
         tmpl = env.from_string(
             """
-        {%- for grouper, list in [{'foo': 1, 'bar': 2}, 
-                                  {'foo': 2, 'bar': 3}, 
-                                  {'foo': 1, 'bar': 1}, 
-                                  {'foo': 3, 'bar': 4}]|groupby('foo') -%} 
-            {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}| 
+        {%- for grouper, list in [{'foo': 1, 'bar': 2},
+                                  {'foo': 2, 'bar': 3},
+                                  {'foo': 1, 'bar': 1},
+                                  {'foo': 3, 'bar': 4}]|groupby('foo') -%}
+            {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}|
         {%- endfor %}"""
         )
         assert tmpl.render().split("|") == ["1: 1, 2: 1, 1", "2: 2, 3", "3: 3, 4", ""]
- 
-    def test_groupby_tuple_index(self, env): 
+
+    def test_groupby_tuple_index(self, env):
         tmpl = env.from_string(
             """
-        {%- for grouper, list in [('a', 1), ('a', 2), ('b', 1)]|groupby(0) -%} 
-            {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}| 
+        {%- for grouper, list in [('a', 1), ('a', 2), ('b', 1)]|groupby(0) -%}
+            {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}|
         {%- endfor %}"""
         )
         assert tmpl.render() == "a:1:2|b:1|"
- 
-    def test_groupby_multidot(self, env): 
+
+    def test_groupby_multidot(self, env):
         Date = namedtuple("Date", "day,month,year")
         Article = namedtuple("Article", "title,date")
-        articles = [ 
+        articles = [
             Article("aha", Date(1, 1, 1970)),
             Article("interesting", Date(2, 1, 1970)),
             Article("really?", Date(3, 1, 1970)),
             Article("totally not", Date(1, 1, 1971)),
-        ] 
+        ]
         tmpl = env.from_string(
             """
-        {%- for year, list in articles|groupby('date.year') -%} 
-            {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}| 
+        {%- for year, list in articles|groupby('date.year') -%}
+            {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}|
         {%- endfor %}"""
         )
         assert tmpl.render(articles=articles).split("|") == [
             "1970[aha][interesting][really?]",
             "1971[totally not]",
             "",
-        ] 
- 
-    def test_filtertag(self, env): 
+        ]
+
+    def test_filtertag(self, env):
         tmpl = env.from_string(
             "{% filter upper|replace('FOO', 'foo') %}foobar{% endfilter %}"
         )
         assert tmpl.render() == "fooBAR"
- 
-    def test_replace(self, env): 
-        env = Environment() 
-        tmpl = env.from_string('{{ string|replace("o", 42) }}') 
+
+    def test_replace(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ string|replace("o", 42) }}')
         assert tmpl.render(string="<foo>") == "<f4242>"
-        env = Environment(autoescape=True) 
-        tmpl = env.from_string('{{ string|replace("o", 42) }}') 
+        env = Environment(autoescape=True)
+        tmpl = env.from_string('{{ string|replace("o", 42) }}')
         assert tmpl.render(string="<foo>") == "&lt;f4242&gt;"
-        tmpl = env.from_string('{{ string|replace("<", 42) }}') 
+        tmpl = env.from_string('{{ string|replace("<", 42) }}')
         assert tmpl.render(string="<foo>") == "42foo&gt;"
-        tmpl = env.from_string('{{ string|replace("o", ">x<") }}') 
+        tmpl = env.from_string('{{ string|replace("o", ">x<") }}')
         assert tmpl.render(string=Markup("foo")) == "f&gt;x&lt;&gt;x&lt;"
- 
-    def test_forceescape(self, env): 
+
+    def test_forceescape(self, env):
         tmpl = env.from_string("{{ x|forceescape }}")
         assert tmpl.render(x=Markup("<div />")) == u"&lt;div /&gt;"
- 
-    def test_safe(self, env): 
-        env = Environment(autoescape=True) 
-        tmpl = env.from_string('{{ "<div>foo</div>"|safe }}') 
+
+    def test_safe(self, env):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string('{{ "<div>foo</div>"|safe }}')
         assert tmpl.render() == "<div>foo</div>"
-        tmpl = env.from_string('{{ "<div>foo</div>" }}') 
+        tmpl = env.from_string('{{ "<div>foo</div>" }}')
         assert tmpl.render() == "&lt;div&gt;foo&lt;/div&gt;"
- 
+
     @pytest.mark.parametrize(
         ("value", "expect"),
         [
@@ -616,32 +616,32 @@ class TestFilter(object):
         e = Environment(autoescape=True)
         t = e.from_string("{{ value|urlencode }}")
         assert t.render(value=value) == expect
- 
-    def test_simple_map(self, env): 
-        env = Environment() 
-        tmpl = env.from_string('{{ ["1", "2", "3"]|map("int")|sum }}') 
+
+    def test_simple_map(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ ["1", "2", "3"]|map("int")|sum }}')
         assert tmpl.render() == "6"
- 
+
     def test_map_sum(self, env):
         tmpl = env.from_string('{{ [[1,2], [3], [4,5,6]]|map("sum")|list }}')
         assert tmpl.render() == "[3, 3, 15]"
 
-    def test_attribute_map(self, env): 
+    def test_attribute_map(self, env):
         User = namedtuple("User", "name")
-        env = Environment() 
-        users = [ 
+        env = Environment()
+        users = [
             User("john"),
             User("jane"),
             User("mike"),
-        ] 
-        tmpl = env.from_string('{{ users|map(attribute="name")|join("|") }}') 
+        ]
+        tmpl = env.from_string('{{ users|map(attribute="name")|join("|") }}')
         assert tmpl.render(users=users) == "john|jane|mike"
- 
-    def test_empty_map(self, env): 
-        env = Environment() 
-        tmpl = env.from_string('{{ none|map("upper")|list }}') 
+
+    def test_empty_map(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ none|map("upper")|list }}')
         assert tmpl.render() == "[]"
- 
+
     def test_map_default(self, env):
         Fullname = namedtuple("Fullname", "firstname,lastname")
         Firstname = namedtuple("Firstname", "firstname")
@@ -657,86 +657,86 @@ class TestFilter(object):
         ]
         assert tmpl.render(users=users) == "lennon, edwards, None, smith"
 
-    def test_simple_select(self, env): 
-        env = Environment() 
-        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|select("odd")|join("|") }}') 
+    def test_simple_select(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|select("odd")|join("|") }}')
         assert tmpl.render() == "1|3|5"
- 
-    def test_bool_select(self, env): 
-        env = Environment() 
+
+    def test_bool_select(self, env):
+        env = Environment()
         tmpl = env.from_string('{{ [none, false, 0, 1, 2, 3, 4, 5]|select|join("|") }}')
         assert tmpl.render() == "1|2|3|4|5"
- 
-    def test_simple_reject(self, env): 
-        env = Environment() 
-        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|reject("odd")|join("|") }}') 
+
+    def test_simple_reject(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|reject("odd")|join("|") }}')
         assert tmpl.render() == "2|4"
- 
-    def test_bool_reject(self, env): 
-        env = Environment() 
+
+    def test_bool_reject(self, env):
+        env = Environment()
         tmpl = env.from_string('{{ [none, false, 0, 1, 2, 3, 4, 5]|reject|join("|") }}')
         assert tmpl.render() == "None|False|0"
- 
-    def test_simple_select_attr(self, env): 
+
+    def test_simple_select_attr(self, env):
         User = namedtuple("User", "name,is_active")
-        env = Environment() 
-        users = [ 
+        env = Environment()
+        users = [
             User("john", True),
             User("jane", True),
             User("mike", False),
-        ] 
-        tmpl = env.from_string( 
+        ]
+        tmpl = env.from_string(
             '{{ users|selectattr("is_active")|map(attribute="name")|join("|") }}'
-        ) 
+        )
         assert tmpl.render(users=users) == "john|jane"
- 
-    def test_simple_reject_attr(self, env): 
+
+    def test_simple_reject_attr(self, env):
         User = namedtuple("User", "name,is_active")
-        env = Environment() 
-        users = [ 
+        env = Environment()
+        users = [
             User("john", True),
             User("jane", True),
             User("mike", False),
-        ] 
+        ]
         tmpl = env.from_string(
             '{{ users|rejectattr("is_active")|map(attribute="name")|join("|") }}'
         )
         assert tmpl.render(users=users) == "mike"
- 
-    def test_func_select_attr(self, env): 
+
+    def test_func_select_attr(self, env):
         User = namedtuple("User", "id,name")
-        env = Environment() 
-        users = [ 
+        env = Environment()
+        users = [
             User(1, "john"),
             User(2, "jane"),
             User(3, "mike"),
-        ] 
+        ]
         tmpl = env.from_string(
             '{{ users|selectattr("id", "odd")|map(attribute="name")|join("|") }}'
         )
         assert tmpl.render(users=users) == "john|mike"
- 
-    def test_func_reject_attr(self, env): 
+
+    def test_func_reject_attr(self, env):
         User = namedtuple("User", "id,name")
-        env = Environment() 
-        users = [ 
+        env = Environment()
+        users = [
             User(1, "john"),
             User(2, "jane"),
             User(3, "mike"),
-        ] 
+        ]
         tmpl = env.from_string(
             '{{ users|rejectattr("id", "odd")|map(attribute="name")|join("|") }}'
         )
         assert tmpl.render(users=users) == "jane"
- 
-    def test_json_dump(self): 
-        env = Environment(autoescape=True) 
+
+    def test_json_dump(self):
+        env = Environment(autoescape=True)
         t = env.from_string("{{ x|tojson }}")
         assert t.render(x={"foo": "bar"}) == '{"foo": "bar"}'
         assert t.render(x="\"ba&r'") == r'"\"ba\u0026r\u0027"'
         assert t.render(x="<bar>") == r'"\u003cbar\u003e"'
- 
-        def my_dumps(value, **options): 
+
+        def my_dumps(value, **options):
             assert options == {"foo": "bar"}
             return "42"
 
diff --git a/contrib/python/Jinja2/py2/tests/test_idtracking.py b/contrib/python/Jinja2/py2/tests/test_idtracking.py
index 2cb8d2dc65..4c79ee6c47 100644
--- a/contrib/python/Jinja2/py2/tests/test_idtracking.py
+++ b/contrib/python/Jinja2/py2/tests/test_idtracking.py
@@ -1,9 +1,9 @@
-from jinja2 import nodes 
-from jinja2.idtracking import symbols_for_node 
- 
- 
-def test_basics(): 
-    for_loop = nodes.For( 
+from jinja2 import nodes
+from jinja2.idtracking import symbols_for_node
+
+
+def test_basics():
+    for_loop = nodes.For(
         nodes.Name("foo", "store"),
         nodes.Name("seq", "load"),
         [nodes.Output([nodes.Name("foo", "load")])],
@@ -14,33 +14,33 @@ def test_basics():
     tmpl = nodes.Template(
         [nodes.Assign(nodes.Name("foo", "store"), nodes.Name("bar", "load")), for_loop]
     )
- 
-    sym = symbols_for_node(tmpl) 
-    assert sym.refs == { 
+
+    sym = symbols_for_node(tmpl)
+    assert sym.refs == {
         "foo": "l_0_foo",
         "bar": "l_0_bar",
         "seq": "l_0_seq",
-    } 
-    assert sym.loads == { 
+    }
+    assert sym.loads == {
         "l_0_foo": ("undefined", None),
         "l_0_bar": ("resolve", "bar"),
         "l_0_seq": ("resolve", "seq"),
-    } 
- 
-    sym = symbols_for_node(for_loop, sym) 
-    assert sym.refs == { 
+    }
+
+    sym = symbols_for_node(for_loop, sym)
+    assert sym.refs == {
         "foo": "l_1_foo",
-    } 
-    assert sym.loads == { 
+    }
+    assert sym.loads == {
         "l_1_foo": ("param", None),
-    } 
- 
- 
-def test_complex(): 
+    }
+
+
+def test_complex():
     title_block = nodes.Block(
         "title", [nodes.Output([nodes.TemplateData(u"Page Title")])], False
     )
- 
+
     render_title_macro = nodes.Macro(
         "render_title",
         [nodes.Name("title", "param")],
@@ -97,8 +97,8 @@ def test_complex():
             ),
         ],
     )
- 
-    for_loop = nodes.For( 
+
+    for_loop = nodes.For(
         nodes.Name("item", "store"),
         nodes.Name("seq", "load"),
         [
@@ -116,7 +116,7 @@ def test_complex():
         None,
         False,
     )
- 
+
     body_block = nodes.Block(
         "body",
         [
@@ -138,7 +138,7 @@ def test_complex():
         ],
         False,
     )
- 
+
     tmpl = nodes.Template(
         [
             nodes.Extends(nodes.Const("layout.html")),
@@ -147,68 +147,68 @@ def test_complex():
             body_block,
         ]
     )
- 
-    tmpl_sym = symbols_for_node(tmpl) 
-    assert tmpl_sym.refs == { 
+
+    tmpl_sym = symbols_for_node(tmpl)
+    assert tmpl_sym.refs == {
         "render_title": "l_0_render_title",
-    } 
-    assert tmpl_sym.loads == { 
+    }
+    assert tmpl_sym.loads == {
         "l_0_render_title": ("undefined", None),
-    } 
+    }
     assert tmpl_sym.stores == set(["render_title"])
-    assert tmpl_sym.dump_stores() == { 
+    assert tmpl_sym.dump_stores() == {
         "render_title": "l_0_render_title",
-    } 
- 
-    macro_sym = symbols_for_node(render_title_macro, tmpl_sym) 
-    assert macro_sym.refs == { 
+    }
+
+    macro_sym = symbols_for_node(render_title_macro, tmpl_sym)
+    assert macro_sym.refs == {
         "subtitle": "l_1_subtitle",
         "something": "l_1_something",
         "title": "l_1_title",
         "title_upper": "l_1_title_upper",
-    } 
-    assert macro_sym.loads == { 
+    }
+    assert macro_sym.loads == {
         "l_1_subtitle": ("resolve", "subtitle"),
         "l_1_something": ("resolve", "something"),
         "l_1_title": ("param", None),
         "l_1_title_upper": ("resolve", "title_upper"),
-    } 
+    }
     assert macro_sym.stores == set(["title", "title_upper", "subtitle"])
     assert macro_sym.find_ref("render_title") == "l_0_render_title"
-    assert macro_sym.dump_stores() == { 
+    assert macro_sym.dump_stores() == {
         "title": "l_1_title",
         "title_upper": "l_1_title_upper",
         "subtitle": "l_1_subtitle",
         "render_title": "l_0_render_title",
-    } 
- 
-    body_sym = symbols_for_node(body_block) 
-    assert body_sym.refs == { 
+    }
+
+    body_sym = symbols_for_node(body_block)
+    assert body_sym.refs == {
         "item": "l_0_item",
         "seq": "l_0_seq",
         "render_title": "l_0_render_title",
-    } 
-    assert body_sym.loads == { 
+    }
+    assert body_sym.loads == {
         "l_0_item": ("resolve", "item"),
         "l_0_seq": ("resolve", "seq"),
         "l_0_render_title": ("resolve", "render_title"),
-    } 
-    assert body_sym.stores == set([]) 
- 
-    for_sym = symbols_for_node(for_loop, body_sym) 
-    assert for_sym.refs == { 
+    }
+    assert body_sym.stores == set([])
+
+    for_sym = symbols_for_node(for_loop, body_sym)
+    assert for_sym.refs == {
         "item": "l_1_item",
-    } 
-    assert for_sym.loads == { 
+    }
+    assert for_sym.loads == {
         "l_1_item": ("param", None),
-    } 
+    }
     assert for_sym.stores == set(["item"])
-    assert for_sym.dump_stores() == { 
+    assert for_sym.dump_stores() == {
         "item": "l_1_item",
-    } 
- 
- 
-def test_if_branching_stores(): 
+    }
+
+
+def test_if_branching_stores():
     tmpl = nodes.Template(
         [
             nodes.If(
@@ -219,20 +219,20 @@ def test_if_branching_stores():
             )
         ]
     )
- 
-    sym = symbols_for_node(tmpl) 
+
+    sym = symbols_for_node(tmpl)
     assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
     assert sym.stores == set(["variable"])
-    assert sym.loads == { 
+    assert sym.loads == {
         "l_0_variable": ("resolve", "variable"),
         "l_0_expression": ("resolve", "expression"),
-    } 
-    assert sym.dump_stores() == { 
+    }
+    assert sym.dump_stores() == {
         "variable": "l_0_variable",
-    } 
- 
- 
-def test_if_branching_stores_undefined(): 
+    }
+
+
+def test_if_branching_stores_undefined():
     tmpl = nodes.Template(
         [
             nodes.Assign(nodes.Name("variable", "store"), nodes.Const(23)),
@@ -244,20 +244,20 @@ def test_if_branching_stores_undefined():
             ),
         ]
     )
- 
-    sym = symbols_for_node(tmpl) 
+
+    sym = symbols_for_node(tmpl)
     assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
     assert sym.stores == set(["variable"])
-    assert sym.loads == { 
+    assert sym.loads == {
         "l_0_variable": ("undefined", None),
         "l_0_expression": ("resolve", "expression"),
-    } 
-    assert sym.dump_stores() == { 
+    }
+    assert sym.dump_stores() == {
         "variable": "l_0_variable",
-    } 
- 
- 
-def test_if_branching_multi_scope(): 
+    }
+
+
+def test_if_branching_multi_scope():
     for_loop = nodes.For(
         nodes.Name("item", "store"),
         nodes.Name("seq", "load"),
@@ -274,16 +274,16 @@ def test_if_branching_multi_scope():
         None,
         False,
     )
- 
+
     tmpl = nodes.Template(
         [nodes.Assign(nodes.Name("x", "store"), nodes.Const(23)), for_loop]
     )
- 
-    tmpl_sym = symbols_for_node(tmpl) 
-    for_sym = symbols_for_node(for_loop, tmpl_sym) 
+
+    tmpl_sym = symbols_for_node(tmpl)
+    for_sym = symbols_for_node(for_loop, tmpl_sym)
     assert for_sym.stores == set(["item", "x"])
-    assert for_sym.loads == { 
+    assert for_sym.loads == {
         "l_1_x": ("alias", "l_0_x"),
         "l_1_item": ("param", None),
         "l_1_expression": ("resolve", "expression"),
-    } 
+    }
diff --git a/contrib/python/Jinja2/py2/tests/test_imports.py b/contrib/python/Jinja2/py2/tests/test_imports.py
index 7f8eb6ef31..fad2edafb6 100644
--- a/contrib/python/Jinja2/py2/tests/test_imports.py
+++ b/contrib/python/Jinja2/py2/tests/test_imports.py
@@ -1,15 +1,15 @@
-# -*- coding: utf-8 -*- 
-import pytest 
- 
+# -*- coding: utf-8 -*-
+import pytest
+
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2.exceptions import TemplateNotFound
 from jinja2.exceptions import TemplatesNotFound
 from jinja2.exceptions import TemplateSyntaxError
- 
- 
-@pytest.fixture 
-def test_env(): 
+
+
+@pytest.fixture
+def test_env():
     env = Environment(
         loader=DictLoader(
             dict(
@@ -20,128 +20,128 @@ def test_env():
         )
     )
     env.globals["bar"] = 23
-    return env 
- 
- 
-class TestImports(object): 
-    def test_context_imports(self, test_env): 
-        t = test_env.from_string('{% import "module" as m %}{{ m.test() }}') 
+    return env
+
+
+class TestImports(object):
+    def test_context_imports(self, test_env):
+        t = test_env.from_string('{% import "module" as m %}{{ m.test() }}')
         assert t.render(foo=42) == "[|23]"
-        t = test_env.from_string( 
-            '{% import "module" as m without context %}{{ m.test() }}' 
-        ) 
+        t = test_env.from_string(
+            '{% import "module" as m without context %}{{ m.test() }}'
+        )
         assert t.render(foo=42) == "[|23]"
-        t = test_env.from_string( 
-            '{% import "module" as m with context %}{{ m.test() }}' 
-        ) 
+        t = test_env.from_string(
+            '{% import "module" as m with context %}{{ m.test() }}'
+        )
         assert t.render(foo=42) == "[42|23]"
-        t = test_env.from_string('{% from "module" import test %}{{ test() }}') 
+        t = test_env.from_string('{% from "module" import test %}{{ test() }}')
         assert t.render(foo=42) == "[|23]"
-        t = test_env.from_string( 
-            '{% from "module" import test without context %}{{ test() }}' 
-        ) 
+        t = test_env.from_string(
+            '{% from "module" import test without context %}{{ test() }}'
+        )
         assert t.render(foo=42) == "[|23]"
-        t = test_env.from_string( 
-            '{% from "module" import test with context %}{{ test() }}' 
-        ) 
+        t = test_env.from_string(
+            '{% from "module" import test with context %}{{ test() }}'
+        )
         assert t.render(foo=42) == "[42|23]"
- 
-    def test_import_needs_name(self, test_env): 
-        test_env.from_string('{% from "foo" import bar %}') 
-        test_env.from_string('{% from "foo" import bar, baz %}') 
- 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import %}') 
- 
-    def test_no_trailing_comma(self, test_env): 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import bar, %}') 
- 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import bar,, %}') 
- 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import, %}') 
- 
-    def test_trailing_comma_with_context(self, test_env): 
-        test_env.from_string('{% from "foo" import bar, baz with context %}') 
-        test_env.from_string('{% from "foo" import bar, baz, with context %}') 
-        test_env.from_string('{% from "foo" import bar, with context %}') 
-        test_env.from_string('{% from "foo" import bar, with, context %}') 
-        test_env.from_string('{% from "foo" import bar, with with context %}') 
- 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import bar,, with context %}') 
- 
-        with pytest.raises(TemplateSyntaxError): 
-            test_env.from_string('{% from "foo" import bar with context, %}') 
- 
-    def test_exports(self, test_env): 
+
+    def test_import_needs_name(self, test_env):
+        test_env.from_string('{% from "foo" import bar %}')
+        test_env.from_string('{% from "foo" import bar, baz %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import %}')
+
+    def test_no_trailing_comma(self, test_env):
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar, %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar,, %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import, %}')
+
+    def test_trailing_comma_with_context(self, test_env):
+        test_env.from_string('{% from "foo" import bar, baz with context %}')
+        test_env.from_string('{% from "foo" import bar, baz, with context %}')
+        test_env.from_string('{% from "foo" import bar, with context %}')
+        test_env.from_string('{% from "foo" import bar, with, context %}')
+        test_env.from_string('{% from "foo" import bar, with with context %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar,, with context %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar with context, %}')
+
+    def test_exports(self, test_env):
         m = test_env.from_string(
             """
-            {% macro toplevel() %}...{% endmacro %} 
-            {% macro __private() %}...{% endmacro %} 
-            {% set variable = 42 %} 
-            {% for item in [1] %} 
-                {% macro notthere() %}{% endmacro %} 
-            {% endfor %} 
+            {% macro toplevel() %}...{% endmacro %}
+            {% macro __private() %}...{% endmacro %}
+            {% set variable = 42 %}
+            {% for item in [1] %}
+                {% macro notthere() %}{% endmacro %}
+            {% endfor %}
         """
         ).module
         assert m.toplevel() == "..."
         assert not hasattr(m, "__missing")
-        assert m.variable == 42 
+        assert m.variable == 42
         assert not hasattr(m, "notthere")
- 
- 
-class TestIncludes(object): 
-    def test_context_include(self, test_env): 
-        t = test_env.from_string('{% include "header" %}') 
+
+
+class TestIncludes(object):
+    def test_context_include(self, test_env):
+        t = test_env.from_string('{% include "header" %}')
         assert t.render(foo=42) == "[42|23]"
-        t = test_env.from_string('{% include "header" with context %}') 
+        t = test_env.from_string('{% include "header" with context %}')
         assert t.render(foo=42) == "[42|23]"
-        t = test_env.from_string('{% include "header" without context %}') 
+        t = test_env.from_string('{% include "header" without context %}')
         assert t.render(foo=42) == "[|23]"
- 
-    def test_choice_includes(self, test_env): 
-        t = test_env.from_string('{% include ["missing", "header"] %}') 
+
+    def test_choice_includes(self, test_env):
+        t = test_env.from_string('{% include ["missing", "header"] %}')
         assert t.render(foo=42) == "[42|23]"
- 
+
         t = test_env.from_string('{% include ["missing", "missing2"] ignore missing %}')
         assert t.render(foo=42) == ""
- 
-        t = test_env.from_string('{% include ["missing", "missing2"] %}') 
-        pytest.raises(TemplateNotFound, t.render) 
+
+        t = test_env.from_string('{% include ["missing", "missing2"] %}')
+        pytest.raises(TemplateNotFound, t.render)
         with pytest.raises(TemplatesNotFound) as e:
-            t.render() 
- 
+            t.render()
+
         assert e.value.templates == ["missing", "missing2"]
         assert e.value.name == "missing2"
 
-        def test_includes(t, **ctx): 
+        def test_includes(t, **ctx):
             ctx["foo"] = 42
             assert t.render(ctx) == "[42|23]"
- 
-        t = test_env.from_string('{% include ["missing", "header"] %}') 
-        test_includes(t) 
+
+        t = test_env.from_string('{% include ["missing", "header"] %}')
+        test_includes(t)
         t = test_env.from_string("{% include x %}")
         test_includes(t, x=["missing", "header"])
-        t = test_env.from_string('{% include [x, "header"] %}') 
+        t = test_env.from_string('{% include [x, "header"] %}')
         test_includes(t, x="missing")
         t = test_env.from_string("{% include x %}")
         test_includes(t, x="header")
         t = test_env.from_string("{% include [x] %}")
         test_includes(t, x="header")
- 
-    def test_include_ignoring_missing(self, test_env): 
-        t = test_env.from_string('{% include "missing" %}') 
-        pytest.raises(TemplateNotFound, t.render) 
+
+    def test_include_ignoring_missing(self, test_env):
+        t = test_env.from_string('{% include "missing" %}')
+        pytest.raises(TemplateNotFound, t.render)
         for extra in "", "with context", "without context":
             t = test_env.from_string(
                 '{% include "missing" ignore missing ' + extra + " %}"
             )
             assert t.render() == ""
- 
-    def test_context_include_with_overrides(self, test_env): 
+
+    def test_context_include_with_overrides(self, test_env):
         env = Environment(
             loader=DictLoader(
                 dict(
@@ -150,23 +150,23 @@ class TestIncludes(object):
                 )
             )
         )
-        assert env.get_template("main").render() == "123" 
- 
-    def test_unoptimized_scopes(self, test_env): 
+        assert env.get_template("main").render() == "123"
+
+    def test_unoptimized_scopes(self, test_env):
         t = test_env.from_string(
             """
-            {% macro outer(o) %} 
-            {% macro inner() %} 
-            {% include "o_printer" %} 
-            {% endmacro %} 
-            {{ inner() }} 
-            {% endmacro %} 
-            {{ outer("FOO") }} 
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
         """
         )
         assert t.render().strip() == "(FOO)"
- 
-    def test_import_from_with_context(self): 
+
+    def test_import_from_with_context(self):
         env = Environment(
             loader=DictLoader({"a": "{% macro x() %}{{ foobar }}{% endmacro %}"})
         )
diff --git a/contrib/python/Jinja2/py2/tests/test_inheritance.py b/contrib/python/Jinja2/py2/tests/test_inheritance.py
index 27baaef7a4..e513d2e3eb 100644
--- a/contrib/python/Jinja2/py2/tests/test_inheritance.py
+++ b/contrib/python/Jinja2/py2/tests/test_inheritance.py
@@ -1,63 +1,63 @@
-# -*- coding: utf-8 -*- 
-import pytest 
- 
+# -*- coding: utf-8 -*-
+import pytest
+
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2 import TemplateRuntimeError
- 
+
 LAYOUTTEMPLATE = """\
-|{% block block1 %}block 1 from layout{% endblock %} 
-|{% block block2 %}block 2 from layout{% endblock %} 
-|{% block block3 %} 
-{% block block4 %}nested block 4 from layout{% endblock %} 
+|{% block block1 %}block 1 from layout{% endblock %}
+|{% block block2 %}block 2 from layout{% endblock %}
+|{% block block3 %}
+{% block block4 %}nested block 4 from layout{% endblock %}
 {% endblock %}|"""
- 
+
 LEVEL1TEMPLATE = """\
-{% extends "layout" %} 
+{% extends "layout" %}
 {% block block1 %}block 1 from level1{% endblock %}"""
- 
+
 LEVEL2TEMPLATE = """\
-{% extends "level1" %} 
-{% block block2 %}{% block block5 %}nested block 5 from level2{% 
+{% extends "level1" %}
+{% block block2 %}{% block block5 %}nested block 5 from level2{%
 endblock %}{% endblock %}"""
- 
+
 LEVEL3TEMPLATE = """\
-{% extends "level2" %} 
-{% block block5 %}block 5 from level3{% endblock %} 
-{% block block4 %}block 4 from level3{% endblock %} 
+{% extends "level2" %}
+{% block block5 %}block 5 from level3{% endblock %}
+{% block block4 %}block 4 from level3{% endblock %}
 """
- 
+
 LEVEL4TEMPLATE = """\
-{% extends "level3" %} 
-{% block block3 %}block 3 from level4{% endblock %} 
+{% extends "level3" %}
+{% block block3 %}block 3 from level4{% endblock %}
 """
- 
+
 WORKINGTEMPLATE = """\
-{% extends "layout" %} 
-{% block block1 %} 
-  {% if false %} 
-    {% block block2 %} 
-      this should workd 
-    {% endblock %} 
-  {% endif %} 
-{% endblock %} 
+{% extends "layout" %}
+{% block block1 %}
+  {% if false %}
+    {% block block2 %}
+      this should workd
+    {% endblock %}
+  {% endif %}
+{% endblock %}
 """
- 
+
 DOUBLEEXTENDS = """\
-{% extends "layout" %} 
-{% extends "layout" %} 
-{% block block1 %} 
-  {% if false %} 
-    {% block block2 %} 
-      this should workd 
-    {% endblock %} 
-  {% endif %} 
-{% endblock %} 
+{% extends "layout" %}
+{% extends "layout" %}
+{% block block1 %}
+  {% if false %}
+    {% block block2 %}
+      this should workd
+    {% endblock %}
+  {% endif %}
+{% endblock %}
 """
- 
- 
-@pytest.fixture 
-def env(): 
+
+
+@pytest.fixture
+def env():
     return Environment(
         loader=DictLoader(
             {
@@ -72,41 +72,41 @@ def env():
         ),
         trim_blocks=True,
     )
- 
- 
-class TestInheritance(object): 
-    def test_layout(self, env): 
+
+
+class TestInheritance(object):
+    def test_layout(self, env):
         tmpl = env.get_template("layout")
         assert tmpl.render() == (
             "|block 1 from layout|block 2 from layout|nested block 4 from layout|"
         )
- 
-    def test_level1(self, env): 
+
+    def test_level1(self, env):
         tmpl = env.get_template("level1")
         assert tmpl.render() == (
             "|block 1 from level1|block 2 from layout|nested block 4 from layout|"
         )
- 
-    def test_level2(self, env): 
+
+    def test_level2(self, env):
         tmpl = env.get_template("level2")
         assert tmpl.render() == (
             "|block 1 from level1|nested block 5 from "
             "level2|nested block 4 from layout|"
         )
- 
-    def test_level3(self, env): 
+
+    def test_level3(self, env):
         tmpl = env.get_template("level3")
         assert tmpl.render() == (
             "|block 1 from level1|block 5 from level3|block 4 from level3|"
         )
- 
-    def test_level4(self, env): 
+
+    def test_level4(self, env):
         tmpl = env.get_template("level4")
         assert tmpl.render() == (
             "|block 1 from level1|block 5 from level3|block 3 from level4|"
         )
- 
-    def test_super(self, env): 
+
+    def test_super(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -122,17 +122,17 @@ class TestInheritance(object):
         )
         tmpl = env.get_template("c")
         assert tmpl.render() == "--INTRO--|BEFORE|[(INNER)]|AFTER"
- 
-    def test_working(self, env): 
+
+    def test_working(self, env):
         env.get_template("working")
- 
-    def test_reuse_blocks(self, env): 
+
+    def test_reuse_blocks(self, env):
         tmpl = env.from_string(
             "{{ self.foo() }}|{% block foo %}42{% endblock %}|{{ self.foo() }}"
         )
         assert tmpl.render() == "42|42|42"
- 
-    def test_preserve_blocks(self, env): 
+
+    def test_preserve_blocks(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -144,8 +144,8 @@ class TestInheritance(object):
         )
         tmpl = env.get_template("b")
         assert tmpl.render() == "BA"
- 
-    def test_dynamic_inheritance(self, env): 
+
+    def test_dynamic_inheritance(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -156,10 +156,10 @@ class TestInheritance(object):
             )
         )
         tmpl = env.get_template("child")
-        for m in range(1, 3): 
+        for m in range(1, 3):
             assert tmpl.render(master="master%d" % m) == "MASTER%dCHILD" % m
- 
-    def test_multi_inheritance(self, env): 
+
+    def test_multi_inheritance(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -174,8 +174,8 @@ class TestInheritance(object):
         assert tmpl.render(master="master2") == "MASTER2CHILD"
         assert tmpl.render(master="master1") == "MASTER1CHILD"
         assert tmpl.render() == "MASTER1CHILD"
- 
-    def test_scoped_block(self, env): 
+
+    def test_scoped_block(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -188,8 +188,8 @@ class TestInheritance(object):
             "{% extends 'master.html' %}{% block item %}{{ item }}{% endblock %}"
         )
         assert t.render(seq=list(range(5))) == "[0][1][2][3][4]"
- 
-    def test_super_in_scoped_block(self, env): 
+
+    def test_super_in_scoped_block(self, env):
         env = Environment(
             loader=DictLoader(
                 {
@@ -203,70 +203,70 @@ class TestInheritance(object):
             "{{ super() }}|{{ item * 2 }}{% endblock %}"
         )
         assert t.render(seq=list(range(5))) == "[0|0][1|2][2|4][3|6][4|8]"
- 
-    def test_scoped_block_after_inheritance(self, env): 
+
+    def test_scoped_block_after_inheritance(self, env):
         env = Environment(
             loader=DictLoader(
                 {
                     "layout.html": """
-            {% block useless %}{% endblock %} 
+            {% block useless %}{% endblock %}
             """,
                     "index.html": """
-            {%- extends 'layout.html' %} 
-            {% from 'helpers.html' import foo with context %} 
-            {% block useless %} 
-                {% for x in [1, 2, 3] %} 
-                    {% block testing scoped %} 
-                        {{ foo(x) }} 
-                    {% endblock %} 
-                {% endfor %} 
-            {% endblock %} 
+            {%- extends 'layout.html' %}
+            {% from 'helpers.html' import foo with context %}
+            {% block useless %}
+                {% for x in [1, 2, 3] %}
+                    {% block testing scoped %}
+                        {{ foo(x) }}
+                    {% endblock %}
+                {% endfor %}
+            {% endblock %}
             """,
                     "helpers.html": """
-            {% macro foo(x) %}{{ the_foo + x }}{% endmacro %} 
+            {% macro foo(x) %}{{ the_foo + x }}{% endmacro %}
             """,
                 }
             )
         )
         rv = env.get_template("index.html").render(the_foo=42).split()
         assert rv == ["43", "44", "45"]
- 
- 
-class TestBugFix(object): 
-    def test_fixed_macro_scoping_bug(self, env): 
+
+
+class TestBugFix(object):
+    def test_fixed_macro_scoping_bug(self, env):
         assert (
             Environment(
                 loader=DictLoader(
                     {
                         "test.html": """\
-        {% extends 'details.html' %} 
- 
-        {% macro my_macro() %} 
-        my_macro 
-        {% endmacro %} 
- 
-        {% block inner_box %} 
-            {{ my_macro() }} 
-        {% endblock %} 
+        {% extends 'details.html' %}
+
+        {% macro my_macro() %}
+        my_macro
+        {% endmacro %}
+
+        {% block inner_box %}
+            {{ my_macro() }}
+        {% endblock %}
             """,
                         "details.html": """\
-        {% extends 'standard.html' %} 
- 
-        {% macro my_macro() %} 
-        my_macro 
-        {% endmacro %} 
- 
-        {% block content %} 
-            {% block outer_box %} 
-                outer_box 
-                {% block inner_box %} 
-                    inner_box 
-                {% endblock %} 
-            {% endblock %} 
-        {% endblock %} 
+        {% extends 'standard.html' %}
+
+        {% macro my_macro() %}
+        my_macro
+        {% endmacro %}
+
+        {% block content %}
+            {% block outer_box %}
+                outer_box
+                {% block inner_box %}
+                    inner_box
+                {% endblock %}
+            {% endblock %}
+        {% endblock %}
         """,
                         "standard.html": """
-        {% block content %}&nbsp;{% endblock %} 
+        {% block content %}&nbsp;{% endblock %}
         """,
                     }
                 )
@@ -276,10 +276,10 @@ class TestBugFix(object):
             .split()
             == [u"outer_box", u"my_macro"]
         )
- 
-    def test_double_extends(self, env): 
-        """Ensures that a template with more than 1 {% extends ... %} usage 
-        raises a ``TemplateError``. 
-        """ 
+
+    def test_double_extends(self, env):
+        """Ensures that a template with more than 1 {% extends ... %} usage
+        raises a ``TemplateError``.
+        """
         with pytest.raises(TemplateRuntimeError, match="extended multiple times"):
             env.get_template("doublee").render()
diff --git a/contrib/python/Jinja2/py2/tests/test_lexnparse.py b/contrib/python/Jinja2/py2/tests/test_lexnparse.py
index 9e83a34621..83ae75e05c 100644
--- a/contrib/python/Jinja2/py2/tests/test_lexnparse.py
+++ b/contrib/python/Jinja2/py2/tests/test_lexnparse.py
@@ -1,6 +1,6 @@
-# -*- coding: utf-8 -*- 
-import pytest 
- 
+# -*- coding: utf-8 -*-
+import pytest
+
 from jinja2 import Environment
 from jinja2 import nodes
 from jinja2 import Template
@@ -14,59 +14,59 @@ from jinja2.lexer import TOKEN_BLOCK_BEGIN
 from jinja2.lexer import TOKEN_BLOCK_END
 from jinja2.lexer import TOKEN_EOF
 from jinja2.lexer import TokenStream
- 
- 
-# how does a string look like in jinja syntax? 
-if PY2: 
 
-    def jinja_string_repr(string): 
-        return repr(string)[1:] 
 
+# how does a string look like in jinja syntax?
+if PY2:
+
+    def jinja_string_repr(string):
+        return repr(string)[1:]
+
+
+else:
+    jinja_string_repr = repr
 
-else: 
-    jinja_string_repr = repr 
- 
- 
-class TestTokenStream(object): 
+
+class TestTokenStream(object):
     test_tokens = [
         Token(1, TOKEN_BLOCK_BEGIN, ""),
         Token(2, TOKEN_BLOCK_END, ""),
     ]
- 
-    def test_simple(self, env): 
-        ts = TokenStream(self.test_tokens, "foo", "bar") 
-        assert ts.current.type is TOKEN_BLOCK_BEGIN 
-        assert bool(ts) 
-        assert not bool(ts.eos) 
-        next(ts) 
-        assert ts.current.type is TOKEN_BLOCK_END 
-        assert bool(ts) 
-        assert not bool(ts.eos) 
-        next(ts) 
-        assert ts.current.type is TOKEN_EOF 
-        assert not bool(ts) 
-        assert bool(ts.eos) 
- 
-    def test_iter(self, env): 
+
+    def test_simple(self, env):
+        ts = TokenStream(self.test_tokens, "foo", "bar")
+        assert ts.current.type is TOKEN_BLOCK_BEGIN
+        assert bool(ts)
+        assert not bool(ts.eos)
+        next(ts)
+        assert ts.current.type is TOKEN_BLOCK_END
+        assert bool(ts)
+        assert not bool(ts.eos)
+        next(ts)
+        assert ts.current.type is TOKEN_EOF
+        assert not bool(ts)
+        assert bool(ts.eos)
+
+    def test_iter(self, env):
         token_types = [t.type for t in TokenStream(self.test_tokens, "foo", "bar")]
         assert token_types == [
             "block_begin",
             "block_end",
-        ] 
- 
- 
-class TestLexer(object): 
-    def test_raw1(self, env): 
-        tmpl = env.from_string( 
+        ]
+
+
+class TestLexer(object):
+    def test_raw1(self, env):
+        tmpl = env.from_string(
             "{% raw %}foo{% endraw %}|"
             "{%raw%}{{ bar }}|{% baz %}{%       endraw    %}"
         )
         assert tmpl.render() == "foo|{{ bar }}|{% baz %}"
- 
-    def test_raw2(self, env): 
+
+    def test_raw2(self, env):
         tmpl = env.from_string("1  {%- raw -%}   2   {%- endraw -%}   3")
         assert tmpl.render() == "123"
- 
+
     def test_raw3(self, env):
         # The second newline after baz exists because it is AFTER the
         # {% raw %} and is ignored.
@@ -83,71 +83,71 @@ class TestLexer(object):
         )
         assert tmpl.render() == "bar2 spaces\n spacefoo"
 
-    def test_balancing(self, env): 
+    def test_balancing(self, env):
         env = Environment("{%", "%}", "${", "}")
         tmpl = env.from_string(
             """{% for item in seq
             %}${{'foo': item}|upper}{% endfor %}"""
         )
         assert tmpl.render(seq=list(range(3))) == "{'FOO': 0}{'FOO': 1}{'FOO': 2}"
- 
-    def test_comments(self, env): 
+
+    def test_comments(self, env):
         env = Environment("<!--", "-->", "{", "}")
         tmpl = env.from_string(
             """\
-<ul> 
-<!--- for item in seq --> 
-  <li>{item}</li> 
-<!--- endfor --> 
+<ul>
+<!--- for item in seq -->
+  <li>{item}</li>
+<!--- endfor -->
 </ul>"""
         )
         assert tmpl.render(seq=list(range(3))) == (
             "<ul>\n  <li>0</li>\n  <li>1</li>\n  <li>2</li>\n</ul>"
         )
- 
-    def test_string_escapes(self, env): 
+
+    def test_string_escapes(self, env):
         for char in u"\0", u"\u2668", u"\xe4", u"\t", u"\r", u"\n":
             tmpl = env.from_string("{{ %s }}" % jinja_string_repr(char))
-            assert tmpl.render() == char 
+            assert tmpl.render() == char
         assert env.from_string('{{ "\N{HOT SPRINGS}" }}').render() == u"\u2668"
- 
-    def test_bytefallback(self, env): 
-        from pprint import pformat 
- 
+
+    def test_bytefallback(self, env):
+        from pprint import pformat
+
         tmpl = env.from_string(u"""{{ 'foo'|pprint }}|{{ 'bär'|pprint }}""")
         assert tmpl.render() == pformat("foo") + "|" + pformat(u"bär")
 
-    def test_operators(self, env): 
-        from jinja2.lexer import operators 
+    def test_operators(self, env):
+        from jinja2.lexer import operators
 
-        for test, expect in iteritems(operators): 
+        for test, expect in iteritems(operators):
             if test in "([{}])":
-                continue 
+                continue
             stream = env.lexer.tokenize("{{ %s }}" % test)
-            next(stream) 
-            assert stream.current.type == expect 
- 
-    def test_normalizing(self, env): 
+            next(stream)
+            assert stream.current.type == expect
+
+    def test_normalizing(self, env):
         for seq in "\r", "\r\n", "\n":
-            env = Environment(newline_sequence=seq) 
+            env = Environment(newline_sequence=seq)
             tmpl = env.from_string("1\n2\r\n3\n4\n")
-            result = tmpl.render() 
+            result = tmpl.render()
             assert result.replace(seq, "X") == "1X2X3X4"
- 
-    def test_trailing_newline(self, env): 
-        for keep in [True, False]: 
-            env = Environment(keep_trailing_newline=keep) 
-            for template, expected in [ 
+
+    def test_trailing_newline(self, env):
+        for keep in [True, False]:
+            env = Environment(keep_trailing_newline=keep)
+            for template, expected in [
                 ("", {}),
                 ("no\nnewline", {}),
                 ("with\nnewline\n", {False: "with\nnewline"}),
                 ("with\nseveral\n\n\n", {False: "with\nseveral\n\n"}),
             ]:
-                tmpl = env.from_string(template) 
-                expect = expected.get(keep, template) 
-                result = tmpl.render() 
-                assert result == expect, (keep, template, result, expect) 
- 
+                tmpl = env.from_string(template)
+                expect = expected.get(keep, template)
+                result = tmpl.render()
+                assert result == expect, (keep, template, result, expect)
+
     @pytest.mark.parametrize(
         "name,valid2,valid3",
         (
@@ -169,15 +169,15 @@ class TestLexer(object):
             (u"a\xb7", False, True),
         ),
     )
-    def test_name(self, env, name, valid2, valid3): 
+    def test_name(self, env, name, valid2, valid3):
         t = u"{{ " + name + u" }}"
- 
-        if (valid2 and PY2) or (valid3 and not PY2): 
-            # valid for version being tested, shouldn't raise 
-            env.from_string(t) 
-        else: 
-            pytest.raises(TemplateSyntaxError, env.from_string, t) 
- 
+
+        if (valid2 and PY2) or (valid3 and not PY2):
+            # valid for version being tested, shouldn't raise
+            env.from_string(t)
+        else:
+            pytest.raises(TemplateSyntaxError, env.from_string, t)
+
     def test_lineno_with_strip(self, env):
         tokens = env.lex(
             """\
@@ -195,110 +195,110 @@ class TestLexer(object):
             if token_type == "name" and value == "item":
                 assert lineno == 5
                 break
- 
 
-class TestParser(object): 
-    def test_php_syntax(self, env): 
+
+class TestParser(object):
+    def test_php_syntax(self, env):
         env = Environment("<?", "?>", "<?=", "?>", "<!--", "-->")
         tmpl = env.from_string(
             """\
-<!-- I'm a comment, I'm not interesting -->\ 
-<? for item in seq -?> 
-    <?= item ?> 
+<!-- I'm a comment, I'm not interesting -->\
+<? for item in seq -?>
+    <?= item ?>
 <?- endfor ?>"""
         )
         assert tmpl.render(seq=list(range(5))) == "01234"
- 
-    def test_erb_syntax(self, env): 
+
+    def test_erb_syntax(self, env):
         env = Environment("<%", "%>", "<%=", "%>", "<%#", "%>")
         tmpl = env.from_string(
             """\
-<%# I'm a comment, I'm not interesting %>\ 
-<% for item in seq -%> 
-    <%= item %> 
+<%# I'm a comment, I'm not interesting %>\
+<% for item in seq -%>
+    <%= item %>
 <%- endfor %>"""
         )
         assert tmpl.render(seq=list(range(5))) == "01234"
- 
-    def test_comment_syntax(self, env): 
+
+    def test_comment_syntax(self, env):
         env = Environment("<!--", "-->", "${", "}", "<!--#", "-->")
         tmpl = env.from_string(
             """\
-<!--# I'm a comment, I'm not interesting -->\ 
-<!-- for item in seq ---> 
-    ${item} 
+<!--# I'm a comment, I'm not interesting -->\
+<!-- for item in seq --->
+    ${item}
 <!--- endfor -->"""
         )
         assert tmpl.render(seq=list(range(5))) == "01234"
- 
-    def test_balancing(self, env): 
+
+    def test_balancing(self, env):
         tmpl = env.from_string("""{{{'foo':'bar'}.foo}}""")
         assert tmpl.render() == "bar"
- 
-    def test_start_comment(self, env): 
+
+    def test_start_comment(self, env):
         tmpl = env.from_string(
             """{# foo comment
-and bar comment #} 
-{% macro blub() %}foo{% endmacro %} 
+and bar comment #}
+{% macro blub() %}foo{% endmacro %}
 {{ blub() }}"""
         )
         assert tmpl.render().strip() == "foo"
- 
-    def test_line_syntax(self, env): 
+
+    def test_line_syntax(self, env):
         env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%")
         tmpl = env.from_string(
             """\
-<%# regular comment %> 
-% for item in seq: 
-    ${item} 
+<%# regular comment %>
+% for item in seq:
+    ${item}
 % endfor"""
         )
-        assert [ 
-            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split() 
-        ] == list(range(5)) 
- 
+        assert [
+            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
+        ] == list(range(5))
+
         env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%", "##")
         tmpl = env.from_string(
             """\
-<%# regular comment %> 
-% for item in seq: 
-    ${item} ## the rest of the stuff 
+<%# regular comment %>
+% for item in seq:
+    ${item} ## the rest of the stuff
 % endfor"""
         )
-        assert [ 
-            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split() 
-        ] == list(range(5)) 
- 
-    def test_line_syntax_priority(self, env): 
-        # XXX: why is the whitespace there in front of the newline? 
+        assert [
+            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
+        ] == list(range(5))
+
+    def test_line_syntax_priority(self, env):
+        # XXX: why is the whitespace there in front of the newline?
         env = Environment("{%", "%}", "${", "}", "/*", "*/", "##", "#")
         tmpl = env.from_string(
             """\
-/* ignore me. 
-   I'm a multiline comment */ 
-## for item in seq: 
-* ${item}          # this is just extra stuff 
+/* ignore me.
+   I'm a multiline comment */
+## for item in seq:
+* ${item}          # this is just extra stuff
 ## endfor"""
         )
         assert tmpl.render(seq=[1, 2]).strip() == "* 1\n* 2"
         env = Environment("{%", "%}", "${", "}", "/*", "*/", "#", "##")
         tmpl = env.from_string(
             """\
-/* ignore me. 
-   I'm a multiline comment */ 
-# for item in seq: 
-* ${item}          ## this is just extra stuff 
-    ## extra stuff i just want to ignore 
+/* ignore me.
+   I'm a multiline comment */
+# for item in seq:
+* ${item}          ## this is just extra stuff
+    ## extra stuff i just want to ignore
 # endfor"""
         )
         assert tmpl.render(seq=[1, 2]).strip() == "* 1\n\n* 2"
- 
-    def test_error_messages(self, env): 
-        def assert_error(code, expected): 
+
+    def test_error_messages(self, env):
+        def assert_error(code, expected):
             with pytest.raises(TemplateSyntaxError, match=expected):
-                Template(code) 
- 
-        assert_error( 
+                Template(code)
+
+        assert_error(
             "{% for item in seq %}...{% endif %}",
             "Encountered unknown tag 'endif'. Jinja was looking "
             "for the following tags: 'endfor' or 'else'. The "
@@ -306,11 +306,11 @@ and bar comment #}
         )
         assert_error(
             "{% if foo %}{% for item in seq %}...{% endfor %}{% endfor %}",
-            "Encountered unknown tag 'endfor'. Jinja was looking for " 
-            "the following tags: 'elif' or 'else' or 'endif'. The " 
+            "Encountered unknown tag 'endfor'. Jinja was looking for "
+            "the following tags: 'elif' or 'else' or 'endif'. The "
             "innermost block that needs to be closed is 'if'.",
         )
-        assert_error( 
+        assert_error(
             "{% if foo %}",
             "Unexpected end of template. Jinja was looking for the "
             "following tags: 'elif' or 'else' or 'endif'. The "
@@ -324,51 +324,51 @@ and bar comment #}
         )
         assert_error(
             "{% block foo-bar-baz %}",
-            "Block names in Jinja have to be valid Python identifiers " 
+            "Block names in Jinja have to be valid Python identifiers "
             "and may not contain hyphens, use an underscore instead.",
         )
         assert_error("{% unknown_tag %}", "Encountered unknown tag 'unknown_tag'.")
- 
- 
-class TestSyntax(object): 
-    def test_call(self, env): 
-        env = Environment() 
+
+
+class TestSyntax(object):
+    def test_call(self, env):
+        env = Environment()
         env.globals["foo"] = lambda a, b, c, e, g: a + b + c + e + g
         tmpl = env.from_string("{{ foo('a', c='d', e='f', *['b'], **{'g': 'h'}) }}")
         assert tmpl.render() == "abdfh"
- 
-    def test_slicing(self, env): 
+
+    def test_slicing(self, env):
         tmpl = env.from_string("{{ [1, 2, 3][:] }}|{{ [1, 2, 3][::-1] }}")
         assert tmpl.render() == "[1, 2, 3]|[3, 2, 1]"
- 
-    def test_attr(self, env): 
-        tmpl = env.from_string("{{ foo.bar }}|{{ foo['bar'] }}") 
+
+    def test_attr(self, env):
+        tmpl = env.from_string("{{ foo.bar }}|{{ foo['bar'] }}")
         assert tmpl.render(foo={"bar": 42}) == "42|42"
- 
-    def test_subscript(self, env): 
-        tmpl = env.from_string("{{ foo[0] }}|{{ foo[-1] }}") 
+
+    def test_subscript(self, env):
+        tmpl = env.from_string("{{ foo[0] }}|{{ foo[-1] }}")
         assert tmpl.render(foo=[0, 1, 2]) == "0|2"
- 
-    def test_tuple(self, env): 
+
+    def test_tuple(self, env):
         tmpl = env.from_string("{{ () }}|{{ (1,) }}|{{ (1, 2) }}")
         assert tmpl.render() == "()|(1,)|(1, 2)"
- 
-    def test_math(self, env): 
+
+    def test_math(self, env):
         tmpl = env.from_string("{{ (1 + 1 * 2) - 3 / 2 }}|{{ 2**3 }}")
         assert tmpl.render() == "1.5|8"
- 
-    def test_div(self, env): 
+
+    def test_div(self, env):
         tmpl = env.from_string("{{ 3 // 2 }}|{{ 3 / 2 }}|{{ 3 % 2 }}")
         assert tmpl.render() == "1|1.5|1"
- 
-    def test_unary(self, env): 
+
+    def test_unary(self, env):
         tmpl = env.from_string("{{ +3 }}|{{ -3 }}")
         assert tmpl.render() == "3|-3"
- 
-    def test_concat(self, env): 
-        tmpl = env.from_string("{{ [1, 2] ~ 'foo' }}") 
+
+    def test_concat(self, env):
+        tmpl = env.from_string("{{ [1, 2] ~ 'foo' }}")
         assert tmpl.render() == "[1, 2]foo"
- 
+
     @pytest.mark.parametrize(
         ("a", "op", "b"),
         [
@@ -383,7 +383,7 @@ class TestSyntax(object):
     def test_compare(self, env, a, op, b):
         t = env.from_string("{{ %d %s %d }}" % (a, op, b))
         assert t.render() == "True"
- 
+
     def test_compare_parens(self, env):
         t = env.from_string("{{ i * (j < 5) }}")
         assert t.render(i=2, j=3) == "2"
@@ -403,15 +403,15 @@ class TestSyntax(object):
         t = env.from_string(src)
         assert t.render(a=4, b=2, c=3) == expect
 
-    def test_inop(self, env): 
+    def test_inop(self, env):
         tmpl = env.from_string("{{ 1 in [1, 2, 3] }}|{{ 1 not in [1, 2, 3] }}")
         assert tmpl.render() == "True|False"
- 
+
     @pytest.mark.parametrize("value", ("[]", "{}", "()"))
     def test_collection_literal(self, env, value):
         t = env.from_string("{{ %s }}" % value)
         assert t.render() == value
- 
+
     @pytest.mark.parametrize(
         ("value", "expect"),
         (
@@ -433,39 +433,39 @@ class TestSyntax(object):
         t = env.from_string("{{ %s }}" % value)
         assert t.render() == expect
 
-    def test_bool(self, env): 
+    def test_bool(self, env):
         tmpl = env.from_string(
             "{{ true and false }}|{{ false or true }}|{{ not false }}"
         )
         assert tmpl.render() == "False|True|True"
- 
-    def test_grouping(self, env): 
-        tmpl = env.from_string( 
+
+    def test_grouping(self, env):
+        tmpl = env.from_string(
             "{{ (true and false) or (false and true) and not false }}"
         )
         assert tmpl.render() == "False"
- 
-    def test_django_attr(self, env): 
+
+    def test_django_attr(self, env):
         tmpl = env.from_string("{{ [1, 2, 3].0 }}|{{ [[1]].0.0 }}")
         assert tmpl.render() == "1|1"
- 
-    def test_conditional_expression(self, env): 
+
+    def test_conditional_expression(self, env):
         tmpl = env.from_string("""{{ 0 if true else 1 }}""")
         assert tmpl.render() == "0"
- 
-    def test_short_conditional_expression(self, env): 
+
+    def test_short_conditional_expression(self, env):
         tmpl = env.from_string("<{{ 1 if false }}>")
         assert tmpl.render() == "<>"
- 
+
         tmpl = env.from_string("<{{ (1 if false).bar }}>")
-        pytest.raises(UndefinedError, tmpl.render) 
- 
-    def test_filter_priority(self, env): 
-        tmpl = env.from_string('{{ "foo"|upper + "bar"|upper }}') 
+        pytest.raises(UndefinedError, tmpl.render)
+
+    def test_filter_priority(self, env):
+        tmpl = env.from_string('{{ "foo"|upper + "bar"|upper }}')
         assert tmpl.render() == "FOOBAR"
- 
-    def test_function_calls(self, env): 
-        tests = [ 
+
+    def test_function_calls(self, env):
+        tests = [
             (True, "*foo, bar"),
             (True, "*foo, *bar"),
             (True, "**foo, *bar"),
@@ -481,17 +481,17 @@ class TestSyntax(object):
             (False, "*foo, **bar"),
             (False, "*foo, bar=42, **baz"),
             (False, "foo, *args, bar=23, **baz"),
-        ] 
-        for should_fail, sig in tests: 
-            if should_fail: 
+        ]
+        for should_fail, sig in tests:
+            if should_fail:
                 pytest.raises(
                     TemplateSyntaxError, env.from_string, "{{ foo(%s) }}" % sig
                 )
-            else: 
+            else:
                 env.from_string("foo(%s)" % sig)
- 
-    def test_tuple_expr(self, env): 
-        for tmpl in [ 
+
+    def test_tuple_expr(self, env):
+        for tmpl in [
             "{{ () }}",
             "{{ (1, 2) }}",
             "{{ (1, 2,) }}",
@@ -500,107 +500,107 @@ class TestSyntax(object):
             "{% for foo, bar in seq %}...{% endfor %}",
             "{% for x in foo, bar %}...{% endfor %}",
             "{% for x in foo, %}...{% endfor %}",
-        ]: 
-            assert env.from_string(tmpl) 
- 
-    def test_trailing_comma(self, env): 
+        ]:
+            assert env.from_string(tmpl)
+
+    def test_trailing_comma(self, env):
         tmpl = env.from_string("{{ (1, 2,) }}|{{ [1, 2,] }}|{{ {1: 2,} }}")
         assert tmpl.render().lower() == "(1, 2)|[1, 2]|{1: 2}"
- 
-    def test_block_end_name(self, env): 
+
+    def test_block_end_name(self, env):
         env.from_string("{% block foo %}...{% endblock foo %}")
         pytest.raises(
             TemplateSyntaxError, env.from_string, "{% block x %}{% endblock y %}"
         )
- 
-    def test_constant_casing(self, env): 
-        for const in True, False, None: 
+
+    def test_constant_casing(self, env):
+        for const in True, False, None:
             tmpl = env.from_string(
                 "{{ %s }}|{{ %s }}|{{ %s }}"
                 % (str(const), str(const).lower(), str(const).upper())
             )
             assert tmpl.render() == "%s|%s|" % (const, const)
- 
-    def test_test_chaining(self, env): 
+
+    def test_test_chaining(self, env):
         pytest.raises(
             TemplateSyntaxError, env.from_string, "{{ foo is string is sequence }}"
         )
         assert env.from_string("{{ 42 is string or 42 is number }}").render() == "True"
- 
-    def test_string_concatenation(self, env): 
-        tmpl = env.from_string('{{ "foo" "bar" "baz" }}') 
+
+    def test_string_concatenation(self, env):
+        tmpl = env.from_string('{{ "foo" "bar" "baz" }}')
         assert tmpl.render() == "foobarbaz"
- 
-    def test_notin(self, env): 
-        bar = range(100) 
+
+    def test_notin(self, env):
+        bar = range(100)
         tmpl = env.from_string("""{{ not 42 in bar }}""")
         assert tmpl.render(bar=bar) == "False"
- 
-    def test_operator_precedence(self, env): 
+
+    def test_operator_precedence(self, env):
         tmpl = env.from_string("""{{ 2 * 3 + 4 % 2 + 1 - 2 }}""")
-        assert tmpl.render() == text_type(2 * 3 + 4 % 2 + 1 - 2) 
- 
-    def test_implicit_subscribed_tuple(self, env): 
-        class Foo(object): 
-            def __getitem__(self, x): 
-                return x 
- 
+        assert tmpl.render() == text_type(2 * 3 + 4 % 2 + 1 - 2)
+
+    def test_implicit_subscribed_tuple(self, env):
+        class Foo(object):
+            def __getitem__(self, x):
+                return x
+
         t = env.from_string("{{ foo[1, 2] }}")
         assert t.render(foo=Foo()) == u"(1, 2)"
 
-    def test_raw2(self, env): 
+    def test_raw2(self, env):
         tmpl = env.from_string("{% raw %}{{ FOO }} and {% BAR %}{% endraw %}")
         assert tmpl.render() == "{{ FOO }} and {% BAR %}"
- 
-    def test_const(self, env): 
-        tmpl = env.from_string( 
+
+    def test_const(self, env):
+        tmpl = env.from_string(
             "{{ true }}|{{ false }}|{{ none }}|"
             "{{ none is defined }}|{{ missing is defined }}"
         )
         assert tmpl.render() == "True|False|None|True|False"
- 
-    def test_neg_filter_priority(self, env): 
+
+    def test_neg_filter_priority(self, env):
         node = env.parse("{{ -1|foo }}")
-        assert isinstance(node.body[0].nodes[0], nodes.Filter) 
-        assert isinstance(node.body[0].nodes[0].node, nodes.Neg) 
- 
-    def test_const_assign(self, env): 
+        assert isinstance(node.body[0].nodes[0], nodes.Filter)
+        assert isinstance(node.body[0].nodes[0].node, nodes.Neg)
+
+    def test_const_assign(self, env):
         constass1 = """{% set true = 42 %}"""
         constass2 = """{% for none in seq %}{% endfor %}"""
-        for tmpl in constass1, constass2: 
-            pytest.raises(TemplateSyntaxError, env.from_string, tmpl) 
- 
-    def test_localset(self, env): 
+        for tmpl in constass1, constass2:
+            pytest.raises(TemplateSyntaxError, env.from_string, tmpl)
+
+    def test_localset(self, env):
         tmpl = env.from_string(
             """{% set foo = 0 %}\
-{% for item in [1, 2] %}{% set foo = 1 %}{% endfor %}\ 
+{% for item in [1, 2] %}{% set foo = 1 %}{% endfor %}\
 {{ foo }}"""
         )
         assert tmpl.render() == "0"
- 
-    def test_parse_unary(self, env): 
-        tmpl = env.from_string('{{ -foo["bar"] }}') 
+
+    def test_parse_unary(self, env):
+        tmpl = env.from_string('{{ -foo["bar"] }}')
         assert tmpl.render(foo={"bar": 42}) == "-42"
-        tmpl = env.from_string('{{ -foo["bar"]|abs }}') 
+        tmpl = env.from_string('{{ -foo["bar"]|abs }}')
         assert tmpl.render(foo={"bar": 42}) == "42"
- 
- 
-class TestLstripBlocks(object): 
-    def test_lstrip(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+
+
+class TestLstripBlocks(object):
+    def test_lstrip(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
-        assert tmpl.render() == "\n" 
- 
-    def test_lstrip_trim(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=True) 
+        assert tmpl.render() == "\n"
+
+    def test_lstrip_trim(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
         tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
-        assert tmpl.render() == "" 
- 
-    def test_no_lstrip(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+        assert tmpl.render() == ""
+
+    def test_no_lstrip(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
-        assert tmpl.render() == "    \n    " 
- 
+        assert tmpl.render() == "    \n    "
+
     def test_lstrip_blocks_false_with_no_lstrip(self, env):
         # Test that + is a NOP (but does not cause an error) if lstrip_blocks=False
         env = Environment(lstrip_blocks=False, trim_blocks=False)
@@ -609,51 +609,51 @@ class TestLstripBlocks(object):
         tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
         assert tmpl.render() == "    \n    "
 
-    def test_lstrip_endline(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+    def test_lstrip_endline(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""    hello{% if True %}\n    goodbye{% endif %}""")
-        assert tmpl.render() == "    hello\n    goodbye" 
- 
-    def test_lstrip_inline(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+        assert tmpl.render() == "    hello\n    goodbye"
+
+    def test_lstrip_inline(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""    {% if True %}hello    {% endif %}""")
         assert tmpl.render() == "hello    "
- 
-    def test_lstrip_nested(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
-        tmpl = env.from_string( 
+
+    def test_lstrip_nested(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
             """    {% if True %}a {% if True %}b {% endif %}c {% endif %}"""
         )
         assert tmpl.render() == "a b c "
- 
-    def test_lstrip_left_chars(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+
+    def test_lstrip_left_chars(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string(
             """    abc {% if True %}
         hello{% endif %}"""
         )
         assert tmpl.render() == "    abc \n        hello"
- 
-    def test_lstrip_embeded_strings(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+
+    def test_lstrip_embeded_strings(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""    {% set x = " {% str %} " %}{{ x }}""")
         assert tmpl.render() == " {% str %} "
- 
-    def test_lstrip_preserve_leading_newlines(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+
+    def test_lstrip_preserve_leading_newlines(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string("""\n\n\n{% set hello = 1 %}""")
         assert tmpl.render() == "\n\n\n"
- 
-    def test_lstrip_comment(self, env): 
-        env = Environment(lstrip_blocks=True, trim_blocks=False) 
+
+    def test_lstrip_comment(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string(
             """    {# if True #}
-hello 
+hello
     {#endif#}"""
         )
         assert tmpl.render() == "\nhello\n"
- 
-    def test_lstrip_angle_bracket_simple(self, env): 
+
+    def test_lstrip_angle_bracket_simple(self, env):
         env = Environment(
             "<%",
             "%>",
@@ -668,8 +668,8 @@ hello
         )
         tmpl = env.from_string("""    <% if True %>hello    <% endif %>""")
         assert tmpl.render() == "hello    "
- 
-    def test_lstrip_angle_bracket_comment(self, env): 
+
+    def test_lstrip_angle_bracket_comment(self, env):
         env = Environment(
             "<%",
             "%>",
@@ -684,8 +684,8 @@ hello
         )
         tmpl = env.from_string("""    <%# if True %>hello    <%# endif %>""")
         assert tmpl.render() == "hello    "
- 
-    def test_lstrip_angle_bracket(self, env): 
+
+    def test_lstrip_angle_bracket(self, env):
         env = Environment(
             "<%",
             "%>",
@@ -700,14 +700,14 @@ hello
         )
         tmpl = env.from_string(
             """\
-    <%# regular comment %> 
-    <% for item in seq %> 
-${item} ## the rest of the stuff 
+    <%# regular comment %>
+    <% for item in seq %>
+${item} ## the rest of the stuff
    <% endfor %>"""
         )
         assert tmpl.render(seq=range(5)) == "".join("%s\n" % x for x in range(5))
- 
-    def test_lstrip_angle_bracket_compact(self, env): 
+
+    def test_lstrip_angle_bracket_compact(self, env):
         env = Environment(
             "<%",
             "%>",
@@ -722,13 +722,13 @@ ${item} ## the rest of the stuff
         )
         tmpl = env.from_string(
             """\
-    <%#regular comment%> 
-    <%for item in seq%> 
-${item} ## the rest of the stuff 
+    <%#regular comment%>
+    <%for item in seq%>
+${item} ## the rest of the stuff
    <%endfor%>"""
         )
         assert tmpl.render(seq=range(5)) == "".join("%s\n" % x for x in range(5))
- 
+
     def test_lstrip_blocks_outside_with_new_line(self):
         env = Environment(lstrip_blocks=True, trim_blocks=False)
         tmpl = env.from_string(
@@ -821,95 +821,95 @@ ${item} ## the rest of the stuff
         out = tmpl.render(x=1, y=2)
         assert out == "1 2"
 
-    def test_php_syntax_with_manual(self, env): 
+    def test_php_syntax_with_manual(self, env):
         env = Environment(
             "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
         )
         tmpl = env.from_string(
             """\
-    <!-- I'm a comment, I'm not interesting --> 
-    <? for item in seq -?> 
-        <?= item ?> 
+    <!-- I'm a comment, I'm not interesting -->
+    <? for item in seq -?>
+        <?= item ?>
     <?- endfor ?>"""
         )
         assert tmpl.render(seq=range(5)) == "01234"
- 
-    def test_php_syntax(self, env): 
+
+    def test_php_syntax(self, env):
         env = Environment(
             "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
         )
         tmpl = env.from_string(
             """\
-    <!-- I'm a comment, I'm not interesting --> 
-    <? for item in seq ?> 
-        <?= item ?> 
+    <!-- I'm a comment, I'm not interesting -->
+    <? for item in seq ?>
+        <?= item ?>
     <? endfor ?>"""
         )
         assert tmpl.render(seq=range(5)) == "".join(
             "        %s\n" % x for x in range(5)
         )
- 
-    def test_php_syntax_compact(self, env): 
+
+    def test_php_syntax_compact(self, env):
         env = Environment(
             "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
         )
         tmpl = env.from_string(
             """\
-    <!-- I'm a comment, I'm not interesting --> 
-    <?for item in seq?> 
-        <?=item?> 
+    <!-- I'm a comment, I'm not interesting -->
+    <?for item in seq?>
+        <?=item?>
     <?endfor?>"""
         )
         assert tmpl.render(seq=range(5)) == "".join(
             "        %s\n" % x for x in range(5)
         )
- 
-    def test_erb_syntax(self, env): 
+
+    def test_erb_syntax(self, env):
         env = Environment(
             "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
         )
-        # env.from_string('') 
-        # for n,r in env.lexer.rules.iteritems(): 
-        #    print n 
-        # print env.lexer.rules['root'][0][0].pattern 
-        # print "'%s'" % tmpl.render(seq=range(5)) 
+        # env.from_string('')
+        # for n,r in env.lexer.rules.iteritems():
+        #    print n
+        # print env.lexer.rules['root'][0][0].pattern
+        # print "'%s'" % tmpl.render(seq=range(5))
         tmpl = env.from_string(
             """\
-<%# I'm a comment, I'm not interesting %> 
-    <% for item in seq %> 
-    <%= item %> 
-    <% endfor %> 
+<%# I'm a comment, I'm not interesting %>
+    <% for item in seq %>
+    <%= item %>
+    <% endfor %>
 """
         )
         assert tmpl.render(seq=range(5)) == "".join("    %s\n" % x for x in range(5))
- 
-    def test_erb_syntax_with_manual(self, env): 
+
+    def test_erb_syntax_with_manual(self, env):
         env = Environment(
             "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
         )
         tmpl = env.from_string(
             """\
-<%# I'm a comment, I'm not interesting %> 
-    <% for item in seq -%> 
-        <%= item %> 
+<%# I'm a comment, I'm not interesting %>
+    <% for item in seq -%>
+        <%= item %>
     <%- endfor %>"""
         )
         assert tmpl.render(seq=range(5)) == "01234"
- 
-    def test_erb_syntax_no_lstrip(self, env): 
+
+    def test_erb_syntax_no_lstrip(self, env):
         env = Environment(
             "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
         )
         tmpl = env.from_string(
             """\
-<%# I'm a comment, I'm not interesting %> 
-    <%+ for item in seq -%> 
-        <%= item %> 
+<%# I'm a comment, I'm not interesting %>
+    <%+ for item in seq -%>
+        <%= item %>
     <%- endfor %>"""
         )
         assert tmpl.render(seq=range(5)) == "    01234"
- 
-    def test_comment_syntax(self, env): 
+
+    def test_comment_syntax(self, env):
         env = Environment(
             "<!--",
             "-->",
@@ -922,9 +922,9 @@ ${item} ## the rest of the stuff
         )
         tmpl = env.from_string(
             """\
-<!--# I'm a comment, I'm not interesting -->\ 
-<!-- for item in seq ---> 
-    ${item} 
+<!--# I'm a comment, I'm not interesting -->\
+<!-- for item in seq --->
+    ${item}
 <!--- endfor -->"""
         )
         assert tmpl.render(seq=range(5)) == "01234"
diff --git a/contrib/python/Jinja2/py2/tests/test_loader.py b/contrib/python/Jinja2/py2/tests/test_loader.py
index 3fa5423774..c613186606 100644
--- a/contrib/python/Jinja2/py2/tests/test_loader.py
+++ b/contrib/python/Jinja2/py2/tests/test_loader.py
@@ -1,11 +1,11 @@
-# -*- coding: utf-8 -*- 
-import os 
+# -*- coding: utf-8 -*-
+import os
 import shutil
-import sys 
-import tempfile 
+import sys
+import tempfile
 import time
-import weakref 
- 
+import weakref
+
 import pytest
 
 from jinja2 import Environment
@@ -13,24 +13,24 @@ from jinja2 import loaders
 from jinja2._compat import PY2
 from jinja2._compat import PYPY
 from jinja2.exceptions import TemplateNotFound
-from jinja2.loaders import split_template_path 
- 
+from jinja2.loaders import split_template_path
+
 import yatest.common as yc
- 
 
-class TestLoaders(object): 
-    def test_dict_loader(self, dict_loader): 
-        env = Environment(loader=dict_loader) 
+
+class TestLoaders(object):
+    def test_dict_loader(self, dict_loader):
+        env = Environment(loader=dict_loader)
         tmpl = env.get_template("justdict.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")
- 
-    def test_package_loader(self, package_loader): 
-        env = Environment(loader=package_loader) 
+
+    def test_package_loader(self, package_loader):
+        env = Environment(loader=package_loader)
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")
- 
+
     def test_filesystem_loader_overlapping_names(self, filesystem_loader):
         res = os.path.dirname(filesystem_loader.searchpath[0])
         t2_dir = os.path.join(res, "templates2")
@@ -40,83 +40,83 @@ class TestLoaders(object):
         e.get_template("foo")
         # This would raise NotADirectoryError if "t2/foo" wasn't skipped.
         e.get_template("foo/test.html")
- 
-    def test_choice_loader(self, choice_loader): 
-        env = Environment(loader=choice_loader) 
+
+    def test_choice_loader(self, choice_loader):
+        env = Environment(loader=choice_loader)
         tmpl = env.get_template("justdict.html")
         assert tmpl.render().strip() == "FOO"
         tmpl = env.get_template("test.html")
         assert tmpl.render().strip() == "BAR"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")
- 
-    def test_function_loader(self, function_loader): 
-        env = Environment(loader=function_loader) 
+
+    def test_function_loader(self, function_loader):
+        env = Environment(loader=function_loader)
         tmpl = env.get_template("justfunction.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing.html")
- 
-    def test_prefix_loader(self, prefix_loader): 
-        env = Environment(loader=prefix_loader) 
+
+    def test_prefix_loader(self, prefix_loader):
+        env = Environment(loader=prefix_loader)
         tmpl = env.get_template("a/test.html")
         assert tmpl.render().strip() == "BAR"
         tmpl = env.get_template("b/justdict.html")
         assert tmpl.render().strip() == "FOO"
         pytest.raises(TemplateNotFound, env.get_template, "missing")
- 
-    def test_caching(self): 
-        changed = False 
- 
-        class TestLoader(loaders.BaseLoader): 
-            def get_source(self, environment, template): 
+
+    def test_caching(self):
+        changed = False
+
+        class TestLoader(loaders.BaseLoader):
+            def get_source(self, environment, template):
                 return u"foo", None, lambda: not changed
 
-        env = Environment(loader=TestLoader(), cache_size=-1) 
+        env = Environment(loader=TestLoader(), cache_size=-1)
         tmpl = env.get_template("template")
         assert tmpl is env.get_template("template")
-        changed = True 
+        changed = True
         assert tmpl is not env.get_template("template")
-        changed = False 
- 
-    def test_no_cache(self): 
+        changed = False
+
+    def test_no_cache(self):
         mapping = {"foo": "one"}
-        env = Environment(loader=loaders.DictLoader(mapping), cache_size=0) 
+        env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
         assert env.get_template("foo") is not env.get_template("foo")
- 
-    def test_limited_size_cache(self): 
+
+    def test_limited_size_cache(self):
         mapping = {"one": "foo", "two": "bar", "three": "baz"}
-        loader = loaders.DictLoader(mapping) 
-        env = Environment(loader=loader, cache_size=2) 
+        loader = loaders.DictLoader(mapping)
+        env = Environment(loader=loader, cache_size=2)
         t1 = env.get_template("one")
         t2 = env.get_template("two")
         assert t2 is env.get_template("two")
         assert t1 is env.get_template("one")
         env.get_template("three")
-        loader_ref = weakref.ref(loader) 
+        loader_ref = weakref.ref(loader)
         assert (loader_ref, "one") in env.cache
         assert (loader_ref, "two") not in env.cache
         assert (loader_ref, "three") in env.cache
- 
-    def test_cache_loader_change(self): 
+
+    def test_cache_loader_change(self):
         loader1 = loaders.DictLoader({"foo": "one"})
         loader2 = loaders.DictLoader({"foo": "two"})
-        env = Environment(loader=loader1, cache_size=2) 
+        env = Environment(loader=loader1, cache_size=2)
         assert env.get_template("foo").render() == "one"
-        env.loader = loader2 
+        env.loader = loader2
         assert env.get_template("foo").render() == "two"
- 
-    def test_dict_loader_cache_invalidates(self): 
+
+    def test_dict_loader_cache_invalidates(self):
         mapping = {"foo": "one"}
-        env = Environment(loader=loaders.DictLoader(mapping)) 
+        env = Environment(loader=loaders.DictLoader(mapping))
         assert env.get_template("foo").render() == "one"
         mapping["foo"] = "two"
         assert env.get_template("foo").render() == "two"
- 
-    def test_split_template_path(self): 
+
+    def test_split_template_path(self):
         assert split_template_path("foo/bar") == ["foo", "bar"]
         assert split_template_path("./foo/bar") == ["foo", "bar"]
         pytest.raises(TemplateNotFound, split_template_path, "../foo")
- 
- 
+
+
 class TestFileSystemLoader(object):
     searchpath = os.path.join(
         yc.test_source_path(), "res", "templates"
@@ -185,33 +185,33 @@ class TestFileSystemLoader(object):
         assert t.render() == expect
 
 
-class TestModuleLoader(object): 
-    archive = None 
- 
+class TestModuleLoader(object):
+    archive = None
+
     def compile_down(self, prefix_loader, zip="deflated", py_compile=False):
-        log = [] 
-        self.reg_env = Environment(loader=prefix_loader) 
-        if zip is not None: 
+        log = []
+        self.reg_env = Environment(loader=prefix_loader)
+        if zip is not None:
             fd, self.archive = tempfile.mkstemp(suffix=".zip")
-            os.close(fd) 
-        else: 
-            self.archive = tempfile.mkdtemp() 
+            os.close(fd)
+        else:
+            self.archive = tempfile.mkdtemp()
         self.reg_env.compile_templates(
             self.archive, zip=zip, log_function=log.append, py_compile=py_compile
         )
-        self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive)) 
+        self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
         return "".join(log)
- 
-    def teardown(self): 
+
+    def teardown(self):
         if hasattr(self, "mod_env"):
-            if os.path.isfile(self.archive): 
-                os.remove(self.archive) 
-            else: 
-                shutil.rmtree(self.archive) 
-            self.archive = None 
- 
-    def test_log(self, prefix_loader): 
-        log = self.compile_down(prefix_loader) 
+            if os.path.isfile(self.archive):
+                os.remove(self.archive)
+            else:
+                shutil.rmtree(self.archive)
+            self.archive = None
+
+    def test_log(self, prefix_loader):
+        log = self.compile_down(prefix_loader)
         assert (
             'Compiled "a/foo/test.html" as '
             "tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a" in log
@@ -221,61 +221,61 @@ class TestModuleLoader(object):
             'Could not compile "a/syntaxerror.html": '
             "Encountered unknown tag 'endif'" in log
         )
- 
-    def _test_common(self): 
+
+    def _test_common(self):
         tmpl1 = self.reg_env.get_template("a/test.html")
         tmpl2 = self.mod_env.get_template("a/test.html")
-        assert tmpl1.render() == tmpl2.render() 
- 
+        assert tmpl1.render() == tmpl2.render()
+
         tmpl1 = self.reg_env.get_template("b/justdict.html")
         tmpl2 = self.mod_env.get_template("b/justdict.html")
-        assert tmpl1.render() == tmpl2.render() 
- 
-    def test_deflated_zip_compile(self, prefix_loader): 
+        assert tmpl1.render() == tmpl2.render()
+
+    def test_deflated_zip_compile(self, prefix_loader):
         self.compile_down(prefix_loader, zip="deflated")
-        self._test_common() 
- 
-    def test_stored_zip_compile(self, prefix_loader): 
+        self._test_common()
+
+    def test_stored_zip_compile(self, prefix_loader):
         self.compile_down(prefix_loader, zip="stored")
-        self._test_common() 
- 
-    def test_filesystem_compile(self, prefix_loader): 
-        self.compile_down(prefix_loader, zip=None) 
-        self._test_common() 
- 
-    def test_weak_references(self, prefix_loader): 
-        self.compile_down(prefix_loader) 
+        self._test_common()
+
+    def test_filesystem_compile(self, prefix_loader):
+        self.compile_down(prefix_loader, zip=None)
+        self._test_common()
+
+    def test_weak_references(self, prefix_loader):
+        self.compile_down(prefix_loader)
         self.mod_env.get_template("a/test.html")
         key = loaders.ModuleLoader.get_template_key("a/test.html")
-        name = self.mod_env.loader.module.__name__ 
- 
-        assert hasattr(self.mod_env.loader.module, key) 
-        assert name in sys.modules 
- 
-        # unset all, ensure the module is gone from sys.modules 
+        name = self.mod_env.loader.module.__name__
+
+        assert hasattr(self.mod_env.loader.module, key)
+        assert name in sys.modules
+
+        # unset all, ensure the module is gone from sys.modules
         self.mod_env = None
- 
-        try: 
-            import gc 
 
-            gc.collect() 
+        try:
+            import gc
+
+            gc.collect()
         except BaseException:
-            pass 
- 
-        assert name not in sys.modules 
- 
-    # This test only makes sense on non-pypy python 2 
-    @pytest.mark.skipif( 
+            pass
+
+        assert name not in sys.modules
+
+    # This test only makes sense on non-pypy python 2
+    @pytest.mark.skipif(
         not (PY2 and not PYPY), reason="This test only makes sense on non-pypy python 2"
     )
-    def test_byte_compilation(self, prefix_loader): 
-        log = self.compile_down(prefix_loader, py_compile=True) 
-        assert 'Byte-compiled "a/test.html"' in log 
+    def test_byte_compilation(self, prefix_loader):
+        log = self.compile_down(prefix_loader, py_compile=True)
+        assert 'Byte-compiled "a/test.html"' in log
         self.mod_env.get_template("a/test.html")
         mod = self.mod_env.loader.module.tmpl_3c4ddf650c1a73df961a6d3d2ce2752f1b8fd490
         assert mod.__file__.endswith(".pyc")
- 
-    def test_choice_loader(self, prefix_loader): 
+
+    def test_choice_loader(self, prefix_loader):
         self.compile_down(prefix_loader)
         self.mod_env.loader = loaders.ChoiceLoader(
             [self.mod_env.loader, loaders.DictLoader({"DICT_SOURCE": "DICT_TEMPLATE"})]
@@ -284,7 +284,7 @@ class TestModuleLoader(object):
         assert tmpl1.render() == "BAR"
         tmpl2 = self.mod_env.get_template("DICT_SOURCE")
         assert tmpl2.render() == "DICT_TEMPLATE"
- 
+
     def test_prefix_loader(self, prefix_loader):
         self.compile_down(prefix_loader)
         self.mod_env.loader = loaders.PrefixLoader(
@@ -297,15 +297,15 @@ class TestModuleLoader(object):
         assert tmpl1.render() == "BAR"
         tmpl2 = self.mod_env.get_template("DICT/test.html")
         assert tmpl2.render() == "DICT_TEMPLATE"
- 
+
     @pytest.mark.skipif(PY2, reason="pathlib is not available in Python 2")
     def test_path_as_pathlib(self, prefix_loader):
         self.compile_down(prefix_loader)
- 
+
         mod_path = self.mod_env.loader.module.__path__[0]
- 
+
         import pathlib
- 
+
         mod_loader = loaders.ModuleLoader(pathlib.Path(mod_path))
         self.mod_env = Environment(loader=mod_loader)
 
diff --git a/contrib/python/Jinja2/py2/tests/test_nativetypes.py b/contrib/python/Jinja2/py2/tests/test_nativetypes.py
index ae845a0aa4..76871ab5de 100644
--- a/contrib/python/Jinja2/py2/tests/test_nativetypes.py
+++ b/contrib/python/Jinja2/py2/tests/test_nativetypes.py
@@ -1,75 +1,75 @@
-import pytest 
- 
-from jinja2._compat import text_type 
-from jinja2.exceptions import UndefinedError 
-from jinja2.nativetypes import NativeEnvironment 
+import pytest
+
+from jinja2._compat import text_type
+from jinja2.exceptions import UndefinedError
+from jinja2.nativetypes import NativeEnvironment
 from jinja2.nativetypes import NativeTemplate
-from jinja2.runtime import Undefined 
- 
- 
-@pytest.fixture 
-def env(): 
-    return NativeEnvironment() 
- 
- 
+from jinja2.runtime import Undefined
+
+
+@pytest.fixture
+def env():
+    return NativeEnvironment()
+
+
 def test_is_defined_native_return(env):
     t = env.from_string("{{ missing is defined }}")
     assert not t.render()
- 
- 
+
+
 def test_undefined_native_return(env):
     t = env.from_string("{{ missing }}")
     assert isinstance(t.render(), Undefined)
- 
- 
+
+
 def test_adding_undefined_native_return(env):
     t = env.from_string("{{ 3 + missing }}")
- 
+
     with pytest.raises(UndefinedError):
         t.render()
- 
- 
+
+
 def test_cast_int(env):
     t = env.from_string("{{ value|int }}")
     result = t.render(value="3")
     assert isinstance(result, int)
     assert result == 3
- 
- 
+
+
 def test_list_add(env):
     t = env.from_string("{{ a + b }}")
     result = t.render(a=["a", "b"], b=["c", "d"])
     assert isinstance(result, list)
     assert result == ["a", "b", "c", "d"]
- 
- 
+
+
 def test_multi_expression_add(env):
     t = env.from_string("{{ a }} + {{ b }}")
     result = t.render(a=["a", "b"], b=["c", "d"])
     assert not isinstance(result, list)
     assert result == "['a', 'b'] + ['c', 'd']"
- 
- 
+
+
 def test_loops(env):
     t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
     result = t.render(value=["a", "b", "c", "d"])
     assert isinstance(result, text_type)
     assert result == "abcd"
- 
- 
+
+
 def test_loops_with_ints(env):
     t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
     result = t.render(value=[1, 2, 3, 4])
     assert isinstance(result, int)
     assert result == 1234
- 
- 
+
+
 def test_loop_look_alike(env):
     t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
     result = t.render(value=[1])
     assert isinstance(result, int)
     assert result == 1
- 
+
 
 @pytest.mark.parametrize(
     ("source", "expect"),
diff --git a/contrib/python/Jinja2/py2/tests/test_regression.py b/contrib/python/Jinja2/py2/tests/test_regression.py
index b442ab25c7..c5a0d68068 100644
--- a/contrib/python/Jinja2/py2/tests/test_regression.py
+++ b/contrib/python/Jinja2/py2/tests/test_regression.py
@@ -1,8 +1,8 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import sys
- 
-import pytest 
- 
+
+import pytest
+
 from jinja2 import DictLoader
 from jinja2 import Environment
 from jinja2 import PrefixLoader
@@ -10,211 +10,211 @@ from jinja2 import Template
 from jinja2 import TemplateAssertionError
 from jinja2 import TemplateNotFound
 from jinja2 import TemplateSyntaxError
-from jinja2._compat import text_type 
- 
- 
-class TestCorner(object): 
-    def test_assigned_scoping(self, env): 
+from jinja2._compat import text_type
+
+
+class TestCorner(object):
+    def test_assigned_scoping(self, env):
         t = env.from_string(
             """
-        {%- for item in (1, 2, 3, 4) -%} 
-            [{{ item }}] 
-        {%- endfor %} 
-        {{- item -}} 
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {{- item -}}
         """
         )
         assert t.render(item=42) == "[1][2][3][4]42"
- 
+
         t = env.from_string(
             """
-        {%- for item in (1, 2, 3, 4) -%} 
-            [{{ item }}] 
-        {%- endfor %} 
-        {%- set item = 42 %} 
-        {{- item -}} 
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {%- set item = 42 %}
+        {{- item -}}
         """
         )
         assert t.render() == "[1][2][3][4]42"
- 
+
         t = env.from_string(
             """
-        {%- set item = 42 %} 
-        {%- for item in (1, 2, 3, 4) -%} 
-            [{{ item }}] 
-        {%- endfor %} 
-        {{- item -}} 
+        {%- set item = 42 %}
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {{- item -}}
         """
         )
         assert t.render() == "[1][2][3][4]42"
- 
-    def test_closure_scoping(self, env): 
+
+    def test_closure_scoping(self, env):
         t = env.from_string(
             """
-        {%- set wrapper = "<FOO>" %} 
-        {%- for item in (1, 2, 3, 4) %} 
-            {%- macro wrapper() %}[{{ item }}]{% endmacro %} 
-            {{- wrapper() }} 
-        {%- endfor %} 
-        {{- wrapper -}} 
+        {%- set wrapper = "<FOO>" %}
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {{- wrapper -}}
         """
         )
         assert t.render() == "[1][2][3][4]<FOO>"
- 
+
         t = env.from_string(
             """
-        {%- for item in (1, 2, 3, 4) %} 
-            {%- macro wrapper() %}[{{ item }}]{% endmacro %} 
-            {{- wrapper() }} 
-        {%- endfor %} 
-        {%- set wrapper = "<FOO>" %} 
-        {{- wrapper -}} 
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {%- set wrapper = "<FOO>" %}
+        {{- wrapper -}}
         """
         )
         assert t.render() == "[1][2][3][4]<FOO>"
- 
+
         t = env.from_string(
             """
-        {%- for item in (1, 2, 3, 4) %} 
-            {%- macro wrapper() %}[{{ item }}]{% endmacro %} 
-            {{- wrapper() }} 
-        {%- endfor %} 
-        {{- wrapper -}} 
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {{- wrapper -}}
         """
         )
         assert t.render(wrapper=23) == "[1][2][3][4]23"
- 
- 
-class TestBug(object): 
-    def test_keyword_folding(self, env): 
-        env = Environment() 
+
+
+class TestBug(object):
+    def test_keyword_folding(self, env):
+        env = Environment()
         env.filters["testing"] = lambda value, some: value + some
         assert (
             env.from_string("{{ 'test'|testing(some='stuff') }}").render()
             == "teststuff"
         )
- 
-    def test_extends_output_bugs(self, env): 
+
+    def test_extends_output_bugs(self, env):
         env = Environment(
             loader=DictLoader({"parent.html": "(({% block title %}{% endblock %}))"})
         )
- 
-        t = env.from_string( 
-            '{% if expr %}{% extends "parent.html" %}{% endif %}' 
+
+        t = env.from_string(
+            '{% if expr %}{% extends "parent.html" %}{% endif %}'
             "[[{% block title %}title{% endblock %}]]"
             "{% for item in [1, 2, 3] %}({{ item }}){% endfor %}"
-        ) 
+        )
         assert t.render(expr=False) == "[[title]](1)(2)(3)"
         assert t.render(expr=True) == "((title))"
- 
-    def test_urlize_filter_escaping(self, env): 
-        tmpl = env.from_string('{{ "http://www.example.org/<foo"|urlize }}') 
+
+    def test_urlize_filter_escaping(self, env):
+        tmpl = env.from_string('{{ "http://www.example.org/<foo"|urlize }}')
         assert (
             tmpl.render() == '<a href="http://www.example.org/&lt;foo" rel="noopener">'
             "http://www.example.org/&lt;foo</a>"
         )
- 
-    def test_loop_call_loop(self, env): 
+
+    def test_loop_call_loop(self, env):
         tmpl = env.from_string(
             """
- 
-        {% macro test() %} 
-            {{ caller() }} 
-        {% endmacro %} 
- 
-        {% for num1 in range(5) %} 
-            {% call test() %} 
-                {% for num2 in range(10) %} 
-                    {{ loop.index }} 
-                {% endfor %} 
-            {% endcall %} 
-        {% endfor %} 
- 
+
+        {% macro test() %}
+            {{ caller() }}
+        {% endmacro %}
+
+        {% for num1 in range(5) %}
+            {% call test() %}
+                {% for num2 in range(10) %}
+                    {{ loop.index }}
+                {% endfor %}
+            {% endcall %}
+        {% endfor %}
+
         """
         )
- 
+
         assert tmpl.render().split() == [text_type(x) for x in range(1, 11)] * 5
- 
-    def test_weird_inline_comment(self, env): 
+
+    def test_weird_inline_comment(self, env):
         env = Environment(line_statement_prefix="%")
         pytest.raises(
             TemplateSyntaxError,
             env.from_string,
             "% for item in seq {# missing #}\n...% endfor",
         )
- 
-    def test_old_macro_loop_scoping_bug(self, env): 
+
+    def test_old_macro_loop_scoping_bug(self, env):
         tmpl = env.from_string(
             "{% for i in (1, 2) %}{{ i }}{% endfor %}"
             "{% macro i() %}3{% endmacro %}{{ i() }}"
         )
         assert tmpl.render() == "123"
- 
-    def test_partial_conditional_assignments(self, env): 
+
+    def test_partial_conditional_assignments(self, env):
         tmpl = env.from_string("{% if b %}{% set a = 42 %}{% endif %}{{ a }}")
         assert tmpl.render(a=23) == "23"
         assert tmpl.render(b=True) == "42"
- 
-    def test_stacked_locals_scoping_bug(self, env): 
+
+    def test_stacked_locals_scoping_bug(self, env):
         env = Environment(line_statement_prefix="#")
         t = env.from_string(
             """\
-# for j in [1, 2]: 
-#   set x = 1 
-#   for i in [1, 2]: 
-#     print x 
-#     if i % 2 == 0: 
-#       set x = x + 1 
-#     endif 
-#   endfor 
-# endfor 
-# if a 
-#   print 'A' 
-# elif b 
-#   print 'B' 
-# elif c == d 
-#   print 'C' 
-# else 
-#   print 'D' 
-# endif 
+# for j in [1, 2]:
+#   set x = 1
+#   for i in [1, 2]:
+#     print x
+#     if i % 2 == 0:
+#       set x = x + 1
+#     endif
+#   endfor
+# endfor
+# if a
+#   print 'A'
+# elif b
+#   print 'B'
+# elif c == d
+#   print 'C'
+# else
+#   print 'D'
+# endif
     """
         )
         assert t.render(a=0, b=False, c=42, d=42.0) == "1111C"
- 
-    def test_stacked_locals_scoping_bug_twoframe(self, env): 
+
+    def test_stacked_locals_scoping_bug_twoframe(self, env):
         t = Template(
             """
-            {% set x = 1 %} 
-            {% for item in foo %} 
-                {% if item == 1 %} 
-                    {% set x = 2 %} 
-                {% endif %} 
-            {% endfor %} 
-            {{ x }} 
+            {% set x = 1 %}
+            {% for item in foo %}
+                {% if item == 1 %}
+                    {% set x = 2 %}
+                {% endif %}
+            {% endfor %}
+            {{ x }}
         """
         )
-        rv = t.render(foo=[1]).strip() 
+        rv = t.render(foo=[1]).strip()
         assert rv == u"1"
- 
-    def test_call_with_args(self, env): 
+
+    def test_call_with_args(self, env):
         t = Template(
             """{% macro dump_users(users) -%}
-        <ul> 
-          {%- for user in users -%} 
-            <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li> 
-          {%- endfor -%} 
-          </ul> 
-        {%- endmacro -%} 
- 
-        {% call(user) dump_users(list_of_user) -%} 
-          <dl> 
-            <dl>Realname</dl> 
-            <dd>{{ user.realname|e }}</dd> 
-            <dl>Description</dl> 
-            <dd>{{ user.description }}</dd> 
-          </dl> 
+        <ul>
+          {%- for user in users -%}
+            <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
+          {%- endfor -%}
+          </ul>
+        {%- endmacro -%}
+
+        {% call(user) dump_users(list_of_user) -%}
+          <dl>
+            <dl>Realname</dl>
+            <dd>{{ user.realname|e }}</dd>
+            <dl>Description</dl>
+            <dd>{{ user.description }}</dd>
+          </dl>
         {% endcall %}"""
         )
- 
+
         assert [
             x.strip()
             for x in t.render(
@@ -234,20 +234,20 @@ class TestBug(object):
             u"<dd>test</dd>",
             u"</dl>",
             u"</li></ul>",
-        ] 
- 
-    def test_empty_if_condition_fails(self, env): 
+        ]
+
+    def test_empty_if_condition_fails(self, env):
         pytest.raises(TemplateSyntaxError, Template, "{% if %}....{% endif %}")
         pytest.raises(
             TemplateSyntaxError, Template, "{% if foo %}...{% elif %}...{% endif %}"
         )
         pytest.raises(TemplateSyntaxError, Template, "{% for x in %}..{% endfor %}")
- 
+
     def test_recursive_loop_compile(self, env):
         Template(
             """
             {% for p in foo recursive%}
-                {{p.bar}} 
+                {{p.bar}}
                 {% for f in p.fields recursive%}
                     {{f.baz}}
                     {{p.bar}}
@@ -255,13 +255,13 @@ class TestBug(object):
                         {{ loop(f.sub) }}
                     {% endif %}
                 {% endfor %}
-            {% endfor %} 
+            {% endfor %}
             """
         )
         Template(
             """
             {% for p in foo%}
-                {{p.bar}} 
+                {{p.bar}}
                 {% for f in p.fields recursive%}
                     {{f.baz}}
                     {{p.bar}}
@@ -269,159 +269,159 @@ class TestBug(object):
                         {{ loop(f.sub) }}
                     {% endif %}
                 {% endfor %}
-            {% endfor %} 
+            {% endfor %}
             """
         )
- 
-    def test_else_loop_bug(self, env): 
+
+    def test_else_loop_bug(self, env):
         t = Template(
             """
-            {% for x in y %} 
-                {{ loop.index0 }} 
-            {% else %} 
-                {% for i in range(3) %}{{ i }}{% endfor %} 
-            {% endfor %} 
+            {% for x in y %}
+                {{ loop.index0 }}
+            {% else %}
+                {% for i in range(3) %}{{ i }}{% endfor %}
+            {% endfor %}
         """
         )
         assert t.render(y=[]).strip() == "012"
- 
-    def test_correct_prefix_loader_name(self, env): 
+
+    def test_correct_prefix_loader_name(self, env):
         env = Environment(loader=PrefixLoader({"foo": DictLoader({})}))
         with pytest.raises(TemplateNotFound) as e:
             env.get_template("foo/bar.html")
- 
+
         assert e.value.name == "foo/bar.html"
 
-    def test_contextfunction_callable_classes(self, env): 
-        from jinja2.utils import contextfunction 
- 
-        class CallableClass(object): 
-            @contextfunction 
-            def __call__(self, ctx): 
+    def test_contextfunction_callable_classes(self, env):
+        from jinja2.utils import contextfunction
+
+        class CallableClass(object):
+            @contextfunction
+            def __call__(self, ctx):
                 return ctx.resolve("hello")
- 
-        tpl = Template("""{{ callableclass() }}""") 
+
+        tpl = Template("""{{ callableclass() }}""")
         output = tpl.render(callableclass=CallableClass(), hello="TEST")
         expected = "TEST"
- 
-        assert output == expected 
- 
+
+        assert output == expected
+
     @pytest.mark.skipif(sys.version_info[0] > 2, reason="This only works on 2.x")
-    def test_old_style_attribute(self, env): 
-        class Foo: 
-            x = 42 
- 
+    def test_old_style_attribute(self, env):
+        class Foo:
+            x = 42
+
         assert env.getitem(Foo(), "x") == 42
 
-    def test_block_set_with_extends(self): 
+    def test_block_set_with_extends(self):
         env = Environment(
             loader=DictLoader({"main": "{% block body %}[{{ x }}]{% endblock %}"})
         )
-        t = env.from_string('{% extends "main" %}{% set x %}42{% endset %}') 
+        t = env.from_string('{% extends "main" %}{% set x %}42{% endset %}')
         assert t.render() == "[42]"
- 
-    def test_nested_for_else(self, env): 
+
+    def test_nested_for_else(self, env):
         tmpl = env.from_string(
             "{% for x in y %}{{ loop.index0 }}{% else %}"
             "{% for i in range(3) %}{{ i }}{% endfor %}"
             "{% endfor %}"
         )
         assert tmpl.render() == "012"
- 
-    def test_macro_var_bug(self, env): 
+
+    def test_macro_var_bug(self, env):
         tmpl = env.from_string(
             """
-        {% set i = 1 %} 
-        {% macro test() %} 
-            {% for i in range(0, 10) %}{{ i }}{% endfor %} 
-        {% endmacro %}{{ test() }} 
+        {% set i = 1 %}
+        {% macro test() %}
+            {% for i in range(0, 10) %}{{ i }}{% endfor %}
+        {% endmacro %}{{ test() }}
         """
         )
         assert tmpl.render().strip() == "0123456789"
- 
-    def test_macro_var_bug_advanced(self, env): 
+
+    def test_macro_var_bug_advanced(self, env):
         tmpl = env.from_string(
             """
-        {% macro outer() %} 
-            {% set i = 1 %} 
-            {% macro test() %} 
-                {% for i in range(0, 10) %}{{ i }}{% endfor %} 
-            {% endmacro %}{{ test() }} 
-        {% endmacro %}{{ outer() }} 
+        {% macro outer() %}
+            {% set i = 1 %}
+            {% macro test() %}
+                {% for i in range(0, 10) %}{{ i }}{% endfor %}
+            {% endmacro %}{{ test() }}
+        {% endmacro %}{{ outer() }}
         """
         )
         assert tmpl.render().strip() == "0123456789"
- 
-    def test_callable_defaults(self): 
-        env = Environment() 
+
+    def test_callable_defaults(self):
+        env = Environment()
         env.globals["get_int"] = lambda: 42
         t = env.from_string(
             """
-        {% macro test(a, b, c=get_int()) -%} 
-             {{ a + b + c }} 
-        {%- endmacro %} 
-        {{ test(1, 2) }}|{{ test(1, 2, 3) }} 
+        {% macro test(a, b, c=get_int()) -%}
+             {{ a + b + c }}
+        {%- endmacro %}
+        {{ test(1, 2) }}|{{ test(1, 2, 3) }}
         """
         )
         assert t.render().strip() == "45|6"
- 
-    def test_macro_escaping(self): 
-        env = Environment( 
+
+    def test_macro_escaping(self):
+        env = Environment(
             autoescape=lambda x: False, extensions=["jinja2.ext.autoescape"]
         )
-        template = "{% macro m() %}<html>{% endmacro %}" 
-        template += "{% autoescape true %}{{ m() }}{% endautoescape %}" 
-        assert env.from_string(template).render() 
- 
-    def test_macro_scoping(self, env): 
+        template = "{% macro m() %}<html>{% endmacro %}"
+        template += "{% autoescape true %}{{ m() }}{% endautoescape %}"
+        assert env.from_string(template).render()
+
+    def test_macro_scoping(self, env):
         tmpl = env.from_string(
             """
-        {% set n=[1,2,3,4,5] %} 
-        {% for n in [[1,2,3], [3,4,5], [5,6,7]] %} 
- 
-        {% macro x(l) %} 
-          {{ l.pop() }} 
-          {% if l %}{{ x(l) }}{% endif %} 
-        {% endmacro %} 
- 
-        {{ x(n) }} 
- 
-        {% endfor %} 
+        {% set n=[1,2,3,4,5] %}
+        {% for n in [[1,2,3], [3,4,5], [5,6,7]] %}
+
+        {% macro x(l) %}
+          {{ l.pop() }}
+          {% if l %}{{ x(l) }}{% endif %}
+        {% endmacro %}
+
+        {{ x(n) }}
+
+        {% endfor %}
         """
         )
         assert list(map(int, tmpl.render().split())) == [3, 2, 1, 5, 4, 3, 7, 6, 5]
- 
-    def test_scopes_and_blocks(self): 
+
+    def test_scopes_and_blocks(self):
         env = Environment(
             loader=DictLoader(
                 {
                     "a.html": """
-                {%- set foo = 'bar' -%} 
-                {% include 'x.html' -%} 
+                {%- set foo = 'bar' -%}
+                {% include 'x.html' -%}
             """,
                     "b.html": """
-                {%- set foo = 'bar' -%} 
-                {% block test %}{% include 'x.html' %}{% endblock -%} 
+                {%- set foo = 'bar' -%}
+                {% block test %}{% include 'x.html' %}{% endblock -%}
                 """,
                     "c.html": """
-                {%- set foo = 'bar' -%} 
-                {% block test %}{% set foo = foo 
-                    %}{% include 'x.html' %}{% endblock -%} 
+                {%- set foo = 'bar' -%}
+                {% block test %}{% set foo = foo
+                    %}{% include 'x.html' %}{% endblock -%}
             """,
                     "x.html": """{{ foo }}|{{ test }}""",
                 }
             )
         )
- 
+
         a = env.get_template("a.html")
         b = env.get_template("b.html")
         c = env.get_template("c.html")
- 
+
         assert a.render(test="x").strip() == "bar|x"
         assert b.render(test="x").strip() == "bar|x"
         assert c.render(test="x").strip() == "bar|x"
- 
-    def test_scopes_and_include(self): 
+
+    def test_scopes_and_include(self):
         env = Environment(
             loader=DictLoader(
                 {
@@ -433,54 +433,54 @@ class TestBug(object):
         )
         t = env.get_template("child.html")
         assert t.render() == "42"
- 
-    def test_caller_scoping(self, env): 
+
+    def test_caller_scoping(self, env):
         t = env.from_string(
             """
-        {% macro detail(icon, value) -%} 
-          {% if value -%} 
-            <p><span class="fa fa-fw fa-{{ icon }}"></span> 
-                {%- if caller is undefined -%} 
-                    {{ value }} 
-                {%- else -%} 
-                    {{ caller(value, *varargs) }} 
-                {%- endif -%}</p> 
-          {%- endif %} 
-        {%- endmacro %} 
- 
- 
-        {% macro link_detail(icon, value, href) -%} 
-          {% call(value, href) detail(icon, value, href) -%} 
-            <a href="{{ href }}">{{ value }}</a> 
-          {%- endcall %} 
-        {%- endmacro %} 
+        {% macro detail(icon, value) -%}
+          {% if value -%}
+            <p><span class="fa fa-fw fa-{{ icon }}"></span>
+                {%- if caller is undefined -%}
+                    {{ value }}
+                {%- else -%}
+                    {{ caller(value, *varargs) }}
+                {%- endif -%}</p>
+          {%- endif %}
+        {%- endmacro %}
+
+
+        {% macro link_detail(icon, value, href) -%}
+          {% call(value, href) detail(icon, value, href) -%}
+            <a href="{{ href }}">{{ value }}</a>
+          {%- endcall %}
+        {%- endmacro %}
         """
         )
- 
+
         assert t.module.link_detail("circle", "Index", "/") == (
             '<p><span class="fa fa-fw fa-circle"></span><a href="/">Index</a></p>'
         )
- 
-    def test_variable_reuse(self, env): 
+
+    def test_variable_reuse(self, env):
         t = env.from_string("{% for x in x.y %}{{ x }}{% endfor %}")
         assert t.render(x={"y": [0, 1, 2]}) == "012"
- 
+
         t = env.from_string("{% for x in x.y %}{{ loop.index0 }}|{{ x }}{% endfor %}")
         assert t.render(x={"y": [0, 1, 2]}) == "0|01|12|2"
- 
+
         t = env.from_string("{% for x in x.y recursive %}{{ x }}{% endfor %}")
         assert t.render(x={"y": [0, 1, 2]}) == "012"
- 
-    def test_double_caller(self, env): 
+
+    def test_double_caller(self, env):
         t = env.from_string(
             "{% macro x(caller=none) %}[{% if caller %}"
             "{{ caller() }}{% endif %}]{% endmacro %}"
             "{{ x() }}{% call x() %}aha!{% endcall %}"
         )
         assert t.render() == "[][aha!]"
- 
-    def test_double_caller_no_default(self, env): 
-        with pytest.raises(TemplateAssertionError) as exc_info: 
+
+    def test_double_caller_no_default(self, env):
+        with pytest.raises(TemplateAssertionError) as exc_info:
             env.from_string(
                 "{% macro x(caller) %}[{% if caller %}"
                 "{{ caller() }}{% endif %}]{% endmacro %}"
@@ -488,59 +488,59 @@ class TestBug(object):
         assert exc_info.match(
             r'"caller" argument must be omitted or ' r"be given a default"
         )
- 
+
         t = env.from_string(
             "{% macro x(caller=none) %}[{% if caller %}"
             "{{ caller() }}{% endif %}]{% endmacro %}"
         )
-        with pytest.raises(TypeError) as exc_info: 
-            t.module.x(None, caller=lambda: 42) 
+        with pytest.raises(TypeError) as exc_info:
+            t.module.x(None, caller=lambda: 42)
         assert exc_info.match(
             r"\'x\' was invoked with two values for the " r"special caller argument"
         )
- 
-    def test_macro_blocks(self, env): 
+
+    def test_macro_blocks(self, env):
         t = env.from_string(
             "{% macro x() %}{% block foo %}x{% endblock %}{% endmacro %}{{ x() }}"
         )
         assert t.render() == "x"
- 
-    def test_scoped_block(self, env): 
+
+    def test_scoped_block(self, env):
         t = env.from_string(
             "{% set x = 1 %}{% with x = 2 %}{% block y scoped %}"
             "{{ x }}{% endblock %}{% endwith %}"
         )
         assert t.render() == "2"
- 
-    def test_recursive_loop_filter(self, env): 
+
+    def test_recursive_loop_filter(self, env):
         t = env.from_string(
             """
-        <?xml version="1.0" encoding="UTF-8"?> 
-        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> 
-          {%- for page in [site.root] if page.url != this recursive %} 
-          <url><loc>{{ page.url }}</loc></url> 
-          {{- loop(page.children) }} 
-          {%- endfor %} 
-        </urlset> 
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in [site.root] if page.url != this recursive %}
+          <url><loc>{{ page.url }}</loc></url>
+          {{- loop(page.children) }}
+          {%- endfor %}
+        </urlset>
         """
         )
         sm = t.render(
             this="/foo",
             site={"root": {"url": "/", "children": [{"url": "/foo"}, {"url": "/bar"}]}},
         )
-        lines = [x.strip() for x in sm.splitlines() if x.strip()] 
-        assert lines == [ 
-            '<?xml version="1.0" encoding="UTF-8"?>', 
-            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">', 
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
             "<url><loc>/</loc></url>",
             "<url><loc>/bar</loc></url>",
             "</urlset>",
-        ] 
- 
-    def test_empty_if(self, env): 
+        ]
+
+    def test_empty_if(self, env):
         t = env.from_string("{% if foo %}{% else %}42{% endif %}")
         assert t.render(foo=False) == "42"
- 
+
     def test_subproperty_if(self, env):
         t = env.from_string(
             "{% if object1.subproperty1 is eq object2.subproperty2 %}42{% endif %}"
@@ -552,7 +552,7 @@ class TestBug(object):
             == "42"
         )
 
-    def test_set_and_include(self): 
+    def test_set_and_include(self):
         env = Environment(
             loader=DictLoader(
                 {
@@ -562,8 +562,8 @@ class TestBug(object):
             )
         )
         assert env.get_template("main").render() == "foobar"
- 
-    def test_loop_include(self): 
+
+    def test_loop_include(self):
         env = Environment(
             loader=DictLoader(
                 {
@@ -573,45 +573,45 @@ class TestBug(object):
             )
         )
         assert env.get_template("main").render() == "123"
- 
-    def test_grouper_repr(self): 
-        from jinja2.filters import _GroupTuple 
+
+    def test_grouper_repr(self):
+        from jinja2.filters import _GroupTuple
 
         t = _GroupTuple("foo", [1, 2])
         assert t.grouper == "foo"
-        assert t.list == [1, 2] 
-        assert repr(t) == "('foo', [1, 2])" 
-        assert str(t) == "('foo', [1, 2])" 
- 
-    def test_custom_context(self, env): 
-        from jinja2.runtime import Context 
- 
-        class MyContext(Context): 
-            pass 
- 
-        class MyEnvironment(Environment): 
-            context_class = MyContext 
- 
+        assert t.list == [1, 2]
+        assert repr(t) == "('foo', [1, 2])"
+        assert str(t) == "('foo', [1, 2])"
+
+    def test_custom_context(self, env):
+        from jinja2.runtime import Context
+
+        class MyContext(Context):
+            pass
+
+        class MyEnvironment(Environment):
+            context_class = MyContext
+
         loader = DictLoader({"base": "{{ foobar }}", "test": '{% extends "base" %}'})
-        env = MyEnvironment(loader=loader) 
+        env = MyEnvironment(loader=loader)
         assert env.get_template("test").render(foobar="test") == "test"
- 
-    def test_legacy_custom_context(self, env): 
+
+    def test_legacy_custom_context(self, env):
         from jinja2.runtime import Context, missing
- 
-        class MyContext(Context): 
-            def resolve(self, name): 
+
+        class MyContext(Context):
+            def resolve(self, name):
                 if name == "foo":
-                    return 42 
-                return super(MyContext, self).resolve(name) 
- 
+                    return 42
+                return super(MyContext, self).resolve(name)
+
         x = MyContext(env, parent={"bar": 23}, name="foo", blocks={})
-        assert x._legacy_resolve_mode 
+        assert x._legacy_resolve_mode
         assert x.resolve_or_missing("foo") == 42
         assert x.resolve_or_missing("bar") == 23
         assert x.resolve_or_missing("baz") is missing
- 
-    def test_recursive_loop_bug(self, env): 
+
+    def test_recursive_loop_bug(self, env):
         tmpl = env.from_string(
             "{%- for value in values recursive %}1{% else %}0{% endfor -%}"
         )
diff --git a/contrib/python/Jinja2/py2/tests/test_security.py b/contrib/python/Jinja2/py2/tests/test_security.py
index 76a7ab079f..7e8974c891 100644
--- a/contrib/python/Jinja2/py2/tests/test_security.py
+++ b/contrib/python/Jinja2/py2/tests/test_security.py
@@ -1,70 +1,70 @@
-# -*- coding: utf-8 -*- 
-import pytest 
- 
-from jinja2 import Environment 
+# -*- coding: utf-8 -*-
+import pytest
+
+from jinja2 import Environment
 from jinja2 import escape
 from jinja2 import Markup
 from jinja2._compat import text_type
 from jinja2.exceptions import SecurityError
 from jinja2.exceptions import TemplateRuntimeError
 from jinja2.exceptions import TemplateSyntaxError
-from jinja2.nodes import EvalContext 
+from jinja2.nodes import EvalContext
 from jinja2.sandbox import ImmutableSandboxedEnvironment
 from jinja2.sandbox import SandboxedEnvironment
 from jinja2.sandbox import unsafe
- 
- 
-class PrivateStuff(object): 
-    def bar(self): 
-        return 23 
- 
-    @unsafe 
-    def foo(self): 
-        return 42 
- 
-    def __repr__(self): 
+
+
+class PrivateStuff(object):
+    def bar(self):
+        return 23
+
+    @unsafe
+    def foo(self):
+        return 42
+
+    def __repr__(self):
         return "PrivateStuff"
- 
- 
-class PublicStuff(object): 
+
+
+class PublicStuff(object):
     def bar(self):
         return 23
- 
+
     def _foo(self):
         return 42
 
-    def __repr__(self): 
+    def __repr__(self):
         return "PublicStuff"
- 
- 
-class TestSandbox(object): 
-    def test_unsafe(self, env): 
-        env = SandboxedEnvironment() 
+
+
+class TestSandbox(object):
+    def test_unsafe(self, env):
+        env = SandboxedEnvironment()
         pytest.raises(
             SecurityError, env.from_string("{{ foo.foo() }}").render, foo=PrivateStuff()
         )
         assert env.from_string("{{ foo.bar() }}").render(foo=PrivateStuff()) == "23"
- 
+
         pytest.raises(
             SecurityError, env.from_string("{{ foo._foo() }}").render, foo=PublicStuff()
         )
         assert env.from_string("{{ foo.bar() }}").render(foo=PublicStuff()) == "23"
         assert env.from_string("{{ foo.__class__ }}").render(foo=42) == ""
         assert env.from_string("{{ foo.func_code }}").render(foo=lambda: None) == ""
-        # security error comes from __class__ already. 
+        # security error comes from __class__ already.
         pytest.raises(
             SecurityError,
             env.from_string("{{ foo.__class__.__subclasses__() }}").render,
             foo=42,
         )
- 
-    def test_immutable_environment(self, env): 
-        env = ImmutableSandboxedEnvironment() 
+
+    def test_immutable_environment(self, env):
+        env = ImmutableSandboxedEnvironment()
         pytest.raises(SecurityError, env.from_string("{{ [].append(23) }}").render)
         pytest.raises(SecurityError, env.from_string("{{ {1:2}.clear() }}").render)
- 
-    def test_restricted(self, env): 
-        env = SandboxedEnvironment() 
+
+    def test_restricted(self, env):
+        env = SandboxedEnvironment()
         pytest.raises(
             TemplateSyntaxError,
             env.from_string,
@@ -75,116 +75,116 @@ class TestSandbox(object):
             env.from_string,
             "{% for foo, bar.baz in seq %}...{% endfor %}",
         )
- 
-    def test_markup_operations(self, env): 
-        # adding two strings should escape the unsafe one 
-        unsafe = '<script type="application/x-some-script">alert("foo");</script>' 
+
+    def test_markup_operations(self, env):
+        # adding two strings should escape the unsafe one
+        unsafe = '<script type="application/x-some-script">alert("foo");</script>'
         safe = Markup("<em>username</em>")
-        assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe) 
- 
-        # string interpolations are safe to use too 
+        assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe)
+
+        # string interpolations are safe to use too
         assert Markup("<em>%s</em>") % "<bad user>" == "<em>&lt;bad user&gt;</em>"
         assert (
             Markup("<em>%(username)s</em>") % {"username": "<bad user>"}
             == "<em>&lt;bad user&gt;</em>"
         )
- 
-        # an escaped object is markup too 
+
+        # an escaped object is markup too
         assert type(Markup("foo") + "bar") is Markup
- 
-        # and it implements __html__ by returning itself 
-        x = Markup("foo") 
-        assert x.__html__() is x 
- 
-        # it also knows how to treat __html__ objects 
-        class Foo(object): 
-            def __html__(self): 
+
+        # and it implements __html__ by returning itself
+        x = Markup("foo")
+        assert x.__html__() is x
+
+        # it also knows how to treat __html__ objects
+        class Foo(object):
+            def __html__(self):
                 return "<em>awesome</em>"
- 
-            def __unicode__(self): 
+
+            def __unicode__(self):
                 return "awesome"
- 
+
         assert Markup(Foo()) == "<em>awesome</em>"
         assert (
             Markup("<strong>%s</strong>") % Foo() == "<strong><em>awesome</em></strong>"
         )
 
-        # escaping and unescaping 
+        # escaping and unescaping
         assert escape("\"<>&'") == "&#34;&lt;&gt;&amp;&#39;"
-        assert Markup("<em>Foo &amp; Bar</em>").striptags() == "Foo & Bar" 
-        assert Markup("&lt;test&gt;").unescape() == "<test>" 
- 
-    def test_template_data(self, env): 
-        env = Environment(autoescape=True) 
+        assert Markup("<em>Foo &amp; Bar</em>").striptags() == "Foo & Bar"
+        assert Markup("&lt;test&gt;").unescape() == "<test>"
+
+    def test_template_data(self, env):
+        env = Environment(autoescape=True)
         t = env.from_string(
             "{% macro say_hello(name) %}"
             "<p>Hello {{ name }}!</p>{% endmacro %}"
             '{{ say_hello("<blink>foo</blink>") }}'
         )
         escaped_out = "<p>Hello &lt;blink&gt;foo&lt;/blink&gt;!</p>"
-        assert t.render() == escaped_out 
-        assert text_type(t.module) == escaped_out 
-        assert escape(t.module) == escaped_out 
+        assert t.render() == escaped_out
+        assert text_type(t.module) == escaped_out
+        assert escape(t.module) == escaped_out
         assert t.module.say_hello("<blink>foo</blink>") == escaped_out
         assert (
             escape(t.module.say_hello(EvalContext(env), "<blink>foo</blink>"))
             == escaped_out
         )
         assert escape(t.module.say_hello("<blink>foo</blink>")) == escaped_out
- 
-    def test_attr_filter(self, env): 
-        env = SandboxedEnvironment() 
-        tmpl = env.from_string('{{ cls|attr("__subclasses__")() }}') 
-        pytest.raises(SecurityError, tmpl.render, cls=int) 
- 
-    def test_binary_operator_intercepting(self, env): 
-        def disable_op(left, right): 
+
+    def test_attr_filter(self, env):
+        env = SandboxedEnvironment()
+        tmpl = env.from_string('{{ cls|attr("__subclasses__")() }}')
+        pytest.raises(SecurityError, tmpl.render, cls=int)
+
+    def test_binary_operator_intercepting(self, env):
+        def disable_op(left, right):
             raise TemplateRuntimeError("that operator so does not work")
 
         for expr, ctx, rv in ("1 + 2", {}, "3"), ("a + 2", {"a": 2}, "4"):
-            env = SandboxedEnvironment() 
+            env = SandboxedEnvironment()
             env.binop_table["+"] = disable_op
             t = env.from_string("{{ %s }}" % expr)
-            assert t.render(ctx) == rv 
+            assert t.render(ctx) == rv
             env.intercepted_binops = frozenset(["+"])
             t = env.from_string("{{ %s }}" % expr)
             with pytest.raises(TemplateRuntimeError):
-                t.render(ctx) 
- 
-    def test_unary_operator_intercepting(self, env): 
-        def disable_op(arg): 
+                t.render(ctx)
+
+    def test_unary_operator_intercepting(self, env):
+        def disable_op(arg):
             raise TemplateRuntimeError("that operator so does not work")
 
         for expr, ctx, rv in ("-1", {}, "-1"), ("-a", {"a": 2}, "-2"):
-            env = SandboxedEnvironment() 
+            env = SandboxedEnvironment()
             env.unop_table["-"] = disable_op
             t = env.from_string("{{ %s }}" % expr)
-            assert t.render(ctx) == rv 
+            assert t.render(ctx) == rv
             env.intercepted_unops = frozenset(["-"])
             t = env.from_string("{{ %s }}" % expr)
             with pytest.raises(TemplateRuntimeError):
-                t.render(ctx) 
- 
- 
-class TestStringFormat(object): 
-    def test_basic_format_safety(self): 
-        env = SandboxedEnvironment() 
-        t = env.from_string('{{ "a{0.__class__}b".format(42) }}') 
+                t.render(ctx)
+
+
+class TestStringFormat(object):
+    def test_basic_format_safety(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{0.__class__}b".format(42) }}')
         assert t.render() == "ab"
- 
-    def test_basic_format_all_okay(self): 
-        env = SandboxedEnvironment() 
-        t = env.from_string('{{ "a{0.foo}b".format({"foo": 42}) }}') 
+
+    def test_basic_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{0.foo}b".format({"foo": 42}) }}')
         assert t.render() == "a42b"
- 
-    def test_safe_format_safety(self): 
-        env = SandboxedEnvironment() 
-        t = env.from_string('{{ ("a{0.__class__}b{1}"|safe).format(42, "<foo>") }}') 
+
+    def test_safe_format_safety(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ ("a{0.__class__}b{1}"|safe).format(42, "<foo>") }}')
         assert t.render() == "ab&lt;foo&gt;"
- 
-    def test_safe_format_all_okay(self): 
-        env = SandboxedEnvironment() 
-        t = env.from_string('{{ ("a{0.foo}b{1}"|safe).format({"foo": 42}, "<foo>") }}') 
+
+    def test_safe_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ ("a{0.foo}b{1}"|safe).format({"foo": 42}, "<foo>") }}')
         assert t.render() == "a42b&lt;foo&gt;"
 
 
diff --git a/contrib/python/Jinja2/py2/tests/test_tests.py b/contrib/python/Jinja2/py2/tests/test_tests.py
index 1c41d1ee0c..b903e3b1e2 100644
--- a/contrib/python/Jinja2/py2/tests/test_tests.py
+++ b/contrib/python/Jinja2/py2/tests/test_tests.py
@@ -1,31 +1,31 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import pytest
- 
+
 from jinja2 import Environment
 from jinja2 import Markup
- 
- 
+
+
 class MyDict(dict):
     pass
- 
- 
-class TestTestsCase(object): 
-    def test_defined(self, env): 
+
+
+class TestTestsCase(object):
+    def test_defined(self, env):
         tmpl = env.from_string("{{ missing is defined }}|{{ true is defined }}")
         assert tmpl.render() == "False|True"
- 
-    def test_even(self, env): 
+
+    def test_even(self, env):
         tmpl = env.from_string("""{{ 1 is even }}|{{ 2 is even }}""")
         assert tmpl.render() == "False|True"
- 
-    def test_odd(self, env): 
+
+    def test_odd(self, env):
         tmpl = env.from_string("""{{ 1 is odd }}|{{ 2 is odd }}""")
         assert tmpl.render() == "True|False"
- 
-    def test_lower(self, env): 
+
+    def test_lower(self, env):
         tmpl = env.from_string("""{{ "foo" is lower }}|{{ "FOO" is lower }}""")
         assert tmpl.render() == "True|False"
- 
+
     # Test type checks
     @pytest.mark.parametrize(
         "op,expect",
@@ -112,27 +112,27 @@ class TestTestsCase(object):
     def test_types(self, env, op, expect):
         t = env.from_string("{{{{ {op} }}}}".format(op=op))
         assert t.render(mydict=MyDict(), complex=complex(1, 2)) == str(expect)
- 
-    def test_upper(self, env): 
-        tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}') 
+
+    def test_upper(self, env):
+        tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}')
         assert tmpl.render() == "True|False"
- 
-    def test_equalto(self, env): 
-        tmpl = env.from_string( 
+
+    def test_equalto(self, env):
+        tmpl = env.from_string(
             "{{ foo is eq 12 }}|"
             "{{ foo is eq 0 }}|"
             "{{ foo is eq (3 * 4) }}|"
-            '{{ bar is eq "baz" }}|' 
-            '{{ bar is eq "zab" }}|' 
-            '{{ bar is eq ("ba" + "z") }}|' 
+            '{{ bar is eq "baz" }}|'
+            '{{ bar is eq "zab" }}|'
+            '{{ bar is eq ("ba" + "z") }}|'
             "{{ bar is eq bar }}|"
             "{{ bar is eq foo }}"
-        ) 
+        )
         assert (
             tmpl.render(foo=12, bar="baz")
             == "True|False|True|True|False|True|True|False"
         )
- 
+
     @pytest.mark.parametrize(
         "op,expect",
         (
@@ -150,39 +150,39 @@ class TestTestsCase(object):
             ("ge 3", False),
         ),
     )
-    def test_compare_aliases(self, env, op, expect): 
+    def test_compare_aliases(self, env, op, expect):
         t = env.from_string("{{{{ 2 is {op} }}}}".format(op=op))
-        assert t.render() == str(expect) 
- 
-    def test_sameas(self, env): 
+        assert t.render() == str(expect)
+
+    def test_sameas(self, env):
         tmpl = env.from_string("{{ foo is sameas false }}|{{ 0 is sameas false }}")
         assert tmpl.render(foo=False) == "True|False"
- 
-    def test_no_paren_for_arg1(self, env): 
+
+    def test_no_paren_for_arg1(self, env):
         tmpl = env.from_string("{{ foo is sameas none }}")
         assert tmpl.render(foo=None) == "True"
- 
-    def test_escaped(self, env): 
-        env = Environment(autoescape=True) 
+
+    def test_escaped(self, env):
+        env = Environment(autoescape=True)
         tmpl = env.from_string("{{ x is escaped }}|{{ y is escaped }}")
         assert tmpl.render(x="foo", y=Markup("foo")) == "False|True"
- 
-    def test_greaterthan(self, env): 
+
+    def test_greaterthan(self, env):
         tmpl = env.from_string("{{ 1 is greaterthan 0 }}|{{ 0 is greaterthan 1 }}")
         assert tmpl.render() == "True|False"
- 
-    def test_lessthan(self, env): 
+
+    def test_lessthan(self, env):
         tmpl = env.from_string("{{ 0 is lessthan 1 }}|{{ 1 is lessthan 0 }}")
         assert tmpl.render() == "True|False"
- 
-    def test_multiple_tests(self): 
-        items = [] 
 
-        def matching(x, y): 
-            items.append((x, y)) 
-            return False 
+    def test_multiple_tests(self):
+        items = []
 
-        env = Environment() 
+        def matching(x, y):
+            items.append((x, y))
+            return False
+
+        env = Environment()
         env.tests["matching"] = matching
         tmpl = env.from_string(
             "{{ 'us-west-1' is matching '(us-east-1|ap-northeast-1)'"
@@ -193,8 +193,8 @@ class TestTestsCase(object):
             ("us-west-1", "(us-east-1|ap-northeast-1)"),
             ("stage", "(dev|stage)"),
         ]
- 
-    def test_in(self, env): 
+
+    def test_in(self, env):
         tmpl = env.from_string(
             '{{ "o" is in "foo" }}|'
             '{{ "foo" is in "foo" }}|'
diff --git a/contrib/python/Jinja2/py2/tests/test_utils.py b/contrib/python/Jinja2/py2/tests/test_utils.py
index 9878251c4e..d9f5bb2783 100644
--- a/contrib/python/Jinja2/py2/tests/test_utils.py
+++ b/contrib/python/Jinja2/py2/tests/test_utils.py
@@ -1,12 +1,12 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 import pickle
 import random
 from collections import deque
 from copy import copy as shallow_copy
- 
-import pytest 
+
+import pytest
 from markupsafe import Markup
- 
+
 from jinja2._compat import range_type
 from jinja2._compat import string_types
 from jinja2.utils import consume
@@ -16,19 +16,19 @@ from jinja2.utils import missing
 from jinja2.utils import object_type_repr
 from jinja2.utils import select_autoescape
 from jinja2.utils import urlize
- 
- 
-class TestLRUCache(object): 
-    def test_simple(self): 
-        d = LRUCache(3) 
-        d["a"] = 1 
-        d["b"] = 2 
-        d["c"] = 3 
-        d["a"] 
-        d["d"] = 4 
-        assert len(d) == 3 
+
+
+class TestLRUCache(object):
+    def test_simple(self):
+        d = LRUCache(3)
+        d["a"] = 1
+        d["b"] = 2
+        d["c"] = 3
+        d["a"]
+        d["d"] = 4
+        assert len(d) == 3
         assert "a" in d and "c" in d and "d" in d and "b" not in d
- 
+
     def test_itervalue_deprecated(self):
         cache = LRUCache(3)
         cache["a"] = 1
@@ -50,18 +50,18 @@ class TestLRUCache(object):
         values = [v for v in cache.values()]
         assert len(values) == 0
 
-    def test_pickleable(self): 
-        cache = LRUCache(2) 
-        cache["foo"] = 42 
-        cache["bar"] = 23 
-        cache["foo"] 
- 
-        for protocol in range(3): 
-            copy = pickle.loads(pickle.dumps(cache, protocol)) 
-            assert copy.capacity == cache.capacity 
-            assert copy._mapping == cache._mapping 
-            assert copy._queue == cache._queue 
- 
+    def test_pickleable(self):
+        cache = LRUCache(2)
+        cache["foo"] = 42
+        cache["bar"] = 23
+        cache["foo"]
+
+        for protocol in range(3):
+            copy = pickle.loads(pickle.dumps(cache, protocol))
+            assert copy.capacity == cache.capacity
+            assert copy._mapping == cache._mapping
+            assert copy._queue == cache._queue
+
     @pytest.mark.parametrize("copy_func", [LRUCache.copy, shallow_copy])
     def test_copy(self, copy_func):
         cache = LRUCache(2)
@@ -72,7 +72,7 @@ class TestLRUCache(object):
         copy["c"] = 3
         assert copy._queue != cache._queue
         assert "a" not in copy and "b" in copy and "c" in copy
- 
+
     def test_clear(self):
         d = LRUCache(3)
         d["a"] = 1
@@ -118,25 +118,25 @@ class TestLRUCache(object):
         assert len(d) == 2
 
 
-class TestHelpers(object): 
-    def test_object_type_repr(self): 
-        class X(object): 
-            pass 
- 
+class TestHelpers(object):
+    def test_object_type_repr(self):
+        class X(object):
+            pass
+
         assert object_type_repr(42) == "int object"
         assert object_type_repr([]) == "list object"
         assert object_type_repr(X()) == "__tests__.test_utils.X object"
         assert object_type_repr(None) == "None"
         assert object_type_repr(Ellipsis) == "Ellipsis"
 
-    def test_autoescape_select(self): 
-        func = select_autoescape( 
+    def test_autoescape_select(self):
+        func = select_autoescape(
             enabled_extensions=("html", ".htm"),
             disabled_extensions=("txt",),
             default_for_string="STRING",
             default="NONE",
-        ) 
- 
+        )
+
         assert func(None) == "STRING"
         assert func("unknown.foo") == "NONE"
         assert func("foo.html")
@@ -144,12 +144,12 @@ class TestHelpers(object):
         assert not func("foo.txt")
         assert func("FOO.HTML")
         assert not func("FOO.TXT")
- 
- 
-class TestEscapeUrlizeTarget(object): 
-    def test_escape_urlize_target(self): 
-        url = "http://example.org" 
-        target = "<script>" 
+
+
+class TestEscapeUrlizeTarget(object):
+    def test_escape_urlize_target(self):
+        url = "http://example.org"
+        target = "<script>"
         assert urlize(url, target=target) == (
             '<a href="http://example.org"'
             ' target="&lt;script&gt;">'