Update Jinja2 (Python template library) to 2.7.1

third_party/jinja2/bccache.py

 # -*- coding: utf-8 -*-
 """
     jinja2.bccache
     ~~~~~~~~~~~~~~
 
     This module implements the bytecode cache system Jinja is optionally
     using.  This is useful if you have very complex template situations and
     the compiliation of all those templates slow down your application too
     much.
 
     Situations where this is useful are often forking web applications that
     are initialized on the first request.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD.
 """
 from os import path, listdir
 import sys
 import marshal
 import tempfile
-import cPickle as pickle
 import fnmatch
-try:
-    from hashlib import sha1
-except ImportError:
-    from sha import new as sha1
+from hashlib import sha1
 from jinja2.utils import open_if_exists
+from jinja2._compat import BytesIO, pickle, PY2, text_type
 
 
 # marshal works better on 3.x, one hack less required
-if sys.version_info > (3, 0):
-    from io import BytesIO
+if not PY2:
     marshal_dump = marshal.dump
     marshal_load = marshal.load
 else:
-    from cStringIO import StringIO as BytesIO
 
     def marshal_dump(code, f):
         if isinstance(f, file):
             marshal.dump(code, f)
         else:
             f.write(marshal.dumps(code))
 
     def marshal_load(f):
         if isinstance(f, file):
             return marshal.load(f)
@@ skipping 111 matching lines @@
         """Clears the cache.  This method is not used by Jinja2 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."""
         hash = sha1(name.encode('utf-8'))
         if filename is not None:
             filename = '|' + filename
-            if isinstance(filename, unicode):
+            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."""
         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
@@ skipping 96 matching lines @@
 
             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, prefix='jinja2/bytecode/', timeout=None):
+    def __init__(self, client, prefix='jinja2/bytecode/', 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):
-        code = self.client.get(self.prefix + bucket.key)
+        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,)
-        self.client.set(*args)
+        try:
+            self.client.set(*args)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise