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

1 files changed, 287 insertions, 287 deletions

diff --git a/contrib/python/Jinja2/py2/jinja2/bccache.py b/contrib/python/Jinja2/py2/jinja2/bccache.py
index 4ed6579d9c5..9c0661030f7 100644
--- a/contrib/python/Jinja2/py2/jinja2/bccache.py
+++ b/contrib/python/Jinja2/py2/jinja2/bccache.py
@@ -1,28 +1,28 @@
-# -*- coding: utf-8 -*- 
+# -*- coding: utf-8 -*-
 """The optional bytecode cache system. This is useful if you have very
 complex template situations and the compilation of all those templates
 slows down your application too much.
- 
+
 Situations where this is useful are often forking web applications that
 are initialized on the first request.
-""" 
+"""
 import errno
 import fnmatch
-import os 
+import os
 import stat
-import sys 
-import tempfile 
-from hashlib import sha1 
+import sys
+import tempfile
+from hashlib import sha1
 from os import listdir
 from os import path
- 
+
 from ._compat import BytesIO
 from ._compat import marshal_dump
 from ._compat import marshal_load
 from ._compat import pickle
 from ._compat import text_type
 from .utils import open_if_exists
- 
+
 bc_version = 4
 # Magic bytes to identify Jinja bytecode cache files. Contains the
 # Python major and minor version to avoid loading incompatible bytecode
@@ -32,291 +32,291 @@ bc_magic = (
     + pickle.dumps(bc_version, 2)
     + pickle.dumps((sys.version_info[0] << 24) | sys.version_info[1], 2)
 )
- 
- 
-class Bucket(object): 
-    """Buckets are used to store the bytecode for one template.  It's created 
-    and initialized by the bytecode cache and passed to the loading functions. 
- 
-    The buckets get an internal checksum from the cache assigned and use this 
-    to automatically reject outdated cache material.  Individual bytecode 
-    cache subclasses don't have to care about cache invalidation. 
-    """ 
- 
-    def __init__(self, environment, key, checksum): 
-        self.environment = environment 
-        self.key = key 
-        self.checksum = checksum 
-        self.reset() 
- 
-    def reset(self): 
-        """Resets the bucket (unloads the bytecode).""" 
-        self.code = None 
- 
-    def load_bytecode(self, f): 
-        """Loads bytecode from a file or file like object.""" 
-        # make sure the magic header is correct 
-        magic = f.read(len(bc_magic)) 
-        if magic != bc_magic: 
-            self.reset() 
-            return 
-        # the source code of the file changed, we need to reload 
-        checksum = pickle.load(f) 
-        if self.checksum != checksum: 
-            self.reset() 
-            return 
-        # if marshal_load fails then we need to reload 
-        try: 
-            self.code = marshal_load(f) 
-        except (EOFError, ValueError, TypeError): 
-            self.reset() 
-            return 
- 
-    def write_bytecode(self, f): 
-        """Dump the bytecode into the file or file like object passed.""" 
-        if self.code is None: 
+
+
+class Bucket(object):
+    """Buckets are used to store the bytecode for one template.  It's created
+    and initialized by the bytecode cache and passed to the loading functions.
+
+    The buckets get an internal checksum from the cache assigned and use this
+    to automatically reject outdated cache material.  Individual bytecode
+    cache subclasses don't have to care about cache invalidation.
+    """
+
+    def __init__(self, environment, key, checksum):
+        self.environment = environment
+        self.key = key
+        self.checksum = checksum
+        self.reset()
+
+    def reset(self):
+        """Resets the bucket (unloads the bytecode)."""
+        self.code = None
+
+    def load_bytecode(self, f):
+        """Loads bytecode from a file or file like object."""
+        # make sure the magic header is correct
+        magic = f.read(len(bc_magic))
+        if magic != bc_magic:
+            self.reset()
+            return
+        # the source code of the file changed, we need to reload
+        checksum = pickle.load(f)
+        if self.checksum != checksum:
+            self.reset()
+            return
+        # if marshal_load fails then we need to reload
+        try:
+            self.code = marshal_load(f)
+        except (EOFError, ValueError, TypeError):
+            self.reset()
+            return
+
+    def write_bytecode(self, f):
+        """Dump the bytecode into the file or file like object passed."""
+        if self.code is None:
             raise TypeError("can't write empty bucket")
-        f.write(bc_magic) 
-        pickle.dump(self.checksum, f, 2) 
-        marshal_dump(self.code, f) 
- 
-    def bytecode_from_string(self, string): 
-        """Load bytecode from a string.""" 
-        self.load_bytecode(BytesIO(string)) 
- 
-    def bytecode_to_string(self): 
-        """Return the bytecode as string.""" 
-        out = BytesIO() 
-        self.write_bytecode(out) 
-        return out.getvalue() 
- 
- 
-class BytecodeCache(object): 
-    """To implement your own bytecode cache you have to subclass this class 
-    and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of 
-    these methods are passed a :class:`~jinja2.bccache.Bucket`. 
- 
-    A very basic bytecode cache that saves the bytecode on the file system:: 
- 
-        from os import path 
- 
-        class MyCache(BytecodeCache): 
- 
-            def __init__(self, directory): 
-                self.directory = directory 
- 
-            def load_bytecode(self, bucket): 
-                filename = path.join(self.directory, bucket.key) 
-                if path.exists(filename): 
-                    with open(filename, 'rb') as f: 
-                        bucket.load_bytecode(f) 
- 
-            def dump_bytecode(self, bucket): 
-                filename = path.join(self.directory, bucket.key) 
-                with open(filename, 'wb') as f: 
-                    bucket.write_bytecode(f) 
- 
-    A more advanced version of a filesystem based bytecode cache is part of 
+        f.write(bc_magic)
+        pickle.dump(self.checksum, f, 2)
+        marshal_dump(self.code, f)
+
+    def bytecode_from_string(self, string):
+        """Load bytecode from a string."""
+        self.load_bytecode(BytesIO(string))
+
+    def bytecode_to_string(self):
+        """Return the bytecode as string."""
+        out = BytesIO()
+        self.write_bytecode(out)
+        return out.getvalue()
+
+
+class BytecodeCache(object):
+    """To implement your own bytecode cache you have to subclass this class
+    and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of
+    these methods are passed a :class:`~jinja2.bccache.Bucket`.
+
+    A very basic bytecode cache that saves the bytecode on the file system::
+
+        from os import path
+
+        class MyCache(BytecodeCache):
+
+            def __init__(self, directory):
+                self.directory = directory
+
+            def load_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                if path.exists(filename):
+                    with open(filename, 'rb') as f:
+                        bucket.load_bytecode(f)
+
+            def dump_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                with open(filename, 'wb') as f:
+                    bucket.write_bytecode(f)
+
+    A more advanced version of a filesystem based bytecode cache is part of
     Jinja.
-    """ 
- 
-    def load_bytecode(self, bucket): 
-        """Subclasses have to override this method to load bytecode into a 
-        bucket.  If they are not able to find code in the cache for the 
-        bucket, it must not do anything. 
-        """ 
-        raise NotImplementedError() 
- 
-    def dump_bytecode(self, bucket): 
-        """Subclasses have to override this method to write the bytecode 
-        from a bucket back to the cache.  If it unable to do so it must not 
-        fail silently but raise an exception. 
-        """ 
-        raise NotImplementedError() 
- 
-    def clear(self): 
+    """
+
+    def load_bytecode(self, bucket):
+        """Subclasses have to override this method to load bytecode into a
+        bucket.  If they are not able to find code in the cache for the
+        bucket, it must not do anything.
+        """
+        raise NotImplementedError()
+
+    def dump_bytecode(self, bucket):
+        """Subclasses have to override this method to write the bytecode
+        from a bucket back to the cache.  If it unable to do so it must not
+        fail silently but raise an exception.
+        """
+        raise NotImplementedError()
+
+    def clear(self):
         """Clears the cache.  This method is not used by Jinja but should be
-        implemented to allow applications to clear the bytecode cache used 
-        by a particular environment. 
-        """ 
- 
-    def get_cache_key(self, name, filename=None): 
-        """Returns the unique hash key for this template name.""" 
+        implemented to allow applications to clear the bytecode cache used
+        by a particular environment.
+        """
+
+    def get_cache_key(self, name, filename=None):
+        """Returns the unique hash key for this template name."""
         hash = sha1(name.encode("utf-8"))
-        if filename is not None: 
+        if filename is not None:
             filename = "|" + filename
-            if isinstance(filename, text_type): 
+            if isinstance(filename, text_type):
                 filename = filename.encode("utf-8")
-            hash.update(filename) 
-        return hash.hexdigest() 
- 
-    def get_source_checksum(self, source): 
-        """Returns a checksum for the source.""" 
+            hash.update(filename)
+        return hash.hexdigest()
+
+    def get_source_checksum(self, source):
+        """Returns a checksum for the source."""
         return sha1(source.encode("utf-8")).hexdigest()
- 
-    def get_bucket(self, environment, name, filename, source): 
-        """Return a cache bucket for the given template.  All arguments are 
-        mandatory but filename may be `None`. 
-        """ 
-        key = self.get_cache_key(name, filename) 
-        checksum = self.get_source_checksum(source) 
-        bucket = Bucket(environment, key, checksum) 
-        self.load_bytecode(bucket) 
-        return bucket 
- 
-    def set_bucket(self, bucket): 
-        """Put the bucket into the cache.""" 
-        self.dump_bytecode(bucket) 
- 
- 
-class FileSystemBytecodeCache(BytecodeCache): 
-    """A bytecode cache that stores bytecode on the filesystem.  It accepts 
-    two arguments: The directory where the cache items are stored and a 
-    pattern string that is used to build the filename. 
- 
-    If no directory is specified a default cache directory is selected.  On 
-    Windows the user's temp directory is used, on UNIX systems a directory 
-    is created for the user in the system temp directory. 
- 
-    The pattern can be used to have multiple separate caches operate on the 
-    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s`` 
-    is replaced with the cache key. 
- 
-    >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache') 
- 
-    This bytecode cache supports clearing of the cache using the clear method. 
-    """ 
- 
+
+    def get_bucket(self, environment, name, filename, source):
+        """Return a cache bucket for the given template.  All arguments are
+        mandatory but filename may be `None`.
+        """
+        key = self.get_cache_key(name, filename)
+        checksum = self.get_source_checksum(source)
+        bucket = Bucket(environment, key, checksum)
+        self.load_bytecode(bucket)
+        return bucket
+
+    def set_bucket(self, bucket):
+        """Put the bucket into the cache."""
+        self.dump_bytecode(bucket)
+
+
+class FileSystemBytecodeCache(BytecodeCache):
+    """A bytecode cache that stores bytecode on the filesystem.  It accepts
+    two arguments: The directory where the cache items are stored and a
+    pattern string that is used to build the filename.
+
+    If no directory is specified a default cache directory is selected.  On
+    Windows the user's temp directory is used, on UNIX systems a directory
+    is created for the user in the system temp directory.
+
+    The pattern can be used to have multiple separate caches operate on the
+    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
+    is replaced with the cache key.
+
+    >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
+
+    This bytecode cache supports clearing of the cache using the clear method.
+    """
+
     def __init__(self, directory=None, pattern="__jinja2_%s.cache"):
-        if directory is None: 
-            directory = self._get_default_cache_dir() 
-        self.directory = directory 
-        self.pattern = pattern 
- 
-    def _get_default_cache_dir(self): 
-        def _unsafe_dir(): 
+        if directory is None:
+            directory = self._get_default_cache_dir()
+        self.directory = directory
+        self.pattern = pattern
+
+    def _get_default_cache_dir(self):
+        def _unsafe_dir():
             raise RuntimeError(
                 "Cannot determine safe temp directory.  You "
                 "need to explicitly provide one."
             )
- 
-        tmpdir = tempfile.gettempdir() 
- 
-        # On windows the temporary directory is used specific unless 
-        # explicitly forced otherwise.  We can just use that. 
+
+        tmpdir = tempfile.gettempdir()
+
+        # On windows the temporary directory is used specific unless
+        # explicitly forced otherwise.  We can just use that.
         if os.name == "nt":
-            return tmpdir 
+            return tmpdir
         if not hasattr(os, "getuid"):
-            _unsafe_dir() 
- 
+            _unsafe_dir()
+
         dirname = "_jinja2-cache-%d" % os.getuid()
-        actual_dir = os.path.join(tmpdir, dirname) 
- 
-        try: 
-            os.mkdir(actual_dir, stat.S_IRWXU) 
-        except OSError as e: 
-            if e.errno != errno.EEXIST: 
-                raise 
-        try: 
-            os.chmod(actual_dir, stat.S_IRWXU) 
-            actual_dir_stat = os.lstat(actual_dir) 
+        actual_dir = os.path.join(tmpdir, dirname)
+
+        try:
+            os.mkdir(actual_dir, stat.S_IRWXU)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        try:
+            os.chmod(actual_dir, stat.S_IRWXU)
+            actual_dir_stat = os.lstat(actual_dir)
             if (
                 actual_dir_stat.st_uid != os.getuid()
                 or not stat.S_ISDIR(actual_dir_stat.st_mode)
                 or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
             ):
-                _unsafe_dir() 
-        except OSError as e: 
-            if e.errno != errno.EEXIST: 
-                raise 
- 
-        actual_dir_stat = os.lstat(actual_dir) 
+                _unsafe_dir()
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        actual_dir_stat = os.lstat(actual_dir)
         if (
             actual_dir_stat.st_uid != os.getuid()
             or not stat.S_ISDIR(actual_dir_stat.st_mode)
             or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
         ):
-            _unsafe_dir() 
- 
-        return actual_dir 
- 
-    def _get_cache_filename(self, bucket): 
-        return path.join(self.directory, self.pattern % bucket.key) 
- 
-    def load_bytecode(self, bucket): 
+            _unsafe_dir()
+
+        return actual_dir
+
+    def _get_cache_filename(self, bucket):
+        return path.join(self.directory, self.pattern % bucket.key)
+
+    def load_bytecode(self, bucket):
         f = open_if_exists(self._get_cache_filename(bucket), "rb")
-        if f is not None: 
-            try: 
-                bucket.load_bytecode(f) 
-            finally: 
-                f.close() 
- 
-    def dump_bytecode(self, bucket): 
+        if f is not None:
+            try:
+                bucket.load_bytecode(f)
+            finally:
+                f.close()
+
+    def dump_bytecode(self, bucket):
         f = open(self._get_cache_filename(bucket), "wb")
-        try: 
-            bucket.write_bytecode(f) 
-        finally: 
-            f.close() 
- 
-    def clear(self): 
-        # imported lazily here because google app-engine doesn't support 
-        # write access on the file system and the function does not exist 
-        # normally. 
-        from os import remove 
+        try:
+            bucket.write_bytecode(f)
+        finally:
+            f.close()
+
+    def clear(self):
+        # imported lazily here because google app-engine doesn't support
+        # write access on the file system and the function does not exist
+        # normally.
+        from os import remove
 
         files = fnmatch.filter(listdir(self.directory), self.pattern % "*")
-        for filename in files: 
-            try: 
-                remove(path.join(self.directory, filename)) 
-            except OSError: 
-                pass 
- 
- 
-class MemcachedBytecodeCache(BytecodeCache): 
-    """This class implements a bytecode cache that uses a memcache cache for 
-    storing the information.  It does not enforce a specific memcache library 
-    (tummy's memcache or cmemcache) but will accept any class that provides 
-    the minimal interface required. 
- 
-    Libraries compatible with this class: 
- 
+        for filename in files:
+            try:
+                remove(path.join(self.directory, filename))
+            except OSError:
+                pass
+
+
+class MemcachedBytecodeCache(BytecodeCache):
+    """This class implements a bytecode cache that uses a memcache cache for
+    storing the information.  It does not enforce a specific memcache library
+    (tummy's memcache or cmemcache) but will accept any class that provides
+    the minimal interface required.
+
+    Libraries compatible with this class:
+
     -   `cachelib <https://github.com/pallets/cachelib>`_
     -   `python-memcached <https://pypi.org/project/python-memcached/>`_
- 
-    (Unfortunately the django cache interface is not compatible because it 
-    does not support storing binary data, only unicode.  You can however pass 
-    the underlying cache client to the bytecode cache which is available 
-    as `django.core.cache.cache._client`.) 
- 
-    The minimal interface for the client passed to the constructor is this: 
- 
-    .. class:: MinimalClientInterface 
- 
-        .. method:: set(key, value[, timeout]) 
- 
-            Stores the bytecode in the cache.  `value` is a string and 
-            `timeout` the timeout of the key.  If timeout is not provided 
-            a default timeout or no timeout should be assumed, if it's 
-            provided it's an integer with the number of seconds the cache 
-            item should exist. 
- 
-        .. method:: get(key) 
- 
-            Returns the value for the cache key.  If the item does not 
-            exist in the cache the return value must be `None`. 
- 
-    The other arguments to the constructor are the prefix for all keys that 
-    is added before the actual cache key and the timeout for the bytecode in 
-    the cache system.  We recommend a high (or no) timeout. 
- 
-    This bytecode cache does not support clearing of used items in the cache. 
-    The clear method is a no-operation function. 
- 
-    .. versionadded:: 2.7 
-       Added support for ignoring memcache errors through the 
-       `ignore_memcache_errors` parameter. 
-    """ 
- 
+
+    (Unfortunately the django cache interface is not compatible because it
+    does not support storing binary data, only unicode.  You can however pass
+    the underlying cache client to the bytecode cache which is available
+    as `django.core.cache.cache._client`.)
+
+    The minimal interface for the client passed to the constructor is this:
+
+    .. class:: MinimalClientInterface
+
+        .. method:: set(key, value[, timeout])
+
+            Stores the bytecode in the cache.  `value` is a string and
+            `timeout` the timeout of the key.  If timeout is not provided
+            a default timeout or no timeout should be assumed, if it's
+            provided it's an integer with the number of seconds the cache
+            item should exist.
+
+        .. method:: get(key)
+
+            Returns the value for the cache key.  If the item does not
+            exist in the cache the return value must be `None`.
+
+    The other arguments to the constructor are the prefix for all keys that
+    is added before the actual cache key and the timeout for the bytecode in
+    the cache system.  We recommend a high (or no) timeout.
+
+    This bytecode cache does not support clearing of used items in the cache.
+    The clear method is a no-operation function.
+
+    .. versionadded:: 2.7
+       Added support for ignoring memcache errors through the
+       `ignore_memcache_errors` parameter.
+    """
+
     def __init__(
         self,
         client,
@@ -324,27 +324,27 @@ class MemcachedBytecodeCache(BytecodeCache):
         timeout=None,
         ignore_memcache_errors=True,
     ):
-        self.client = client 
-        self.prefix = prefix 
-        self.timeout = timeout 
-        self.ignore_memcache_errors = ignore_memcache_errors 
- 
-    def load_bytecode(self, bucket): 
-        try: 
-            code = self.client.get(self.prefix + bucket.key) 
-        except Exception: 
-            if not self.ignore_memcache_errors: 
-                raise 
-            code = None 
-        if code is not None: 
-            bucket.bytecode_from_string(code) 
- 
-    def dump_bytecode(self, bucket): 
-        args = (self.prefix + bucket.key, bucket.bytecode_to_string()) 
-        if self.timeout is not None: 
-            args += (self.timeout,) 
-        try: 
-            self.client.set(*args) 
-        except Exception: 
-            if not self.ignore_memcache_errors: 
-                raise 
+        self.client = client
+        self.prefix = prefix
+        self.timeout = timeout
+        self.ignore_memcache_errors = ignore_memcache_errors
+
+    def load_bytecode(self, bucket):
+        try:
+            code = self.client.get(self.prefix + bucket.key)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise
+            code = None
+        if code is not None:
+            bucket.bytecode_from_string(code)
+
+    def dump_bytecode(self, bucket):
+        args = (self.prefix + bucket.key, bucket.bytecode_to_string())
+        if self.timeout is not None:
+            args += (self.timeout,)
+        try:
+            self.client.set(*args)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise