Ticket #14290: ticket14290_for_12.diff

django/template/defaultfilters.py

@@ -706 +706 @@
         arg = settings.DATE_FORMAT
     try:
         return formats.date_format(value, arg)
-    except AttributeError:
+    except (AttributeError, UnicodeEncodeError):
         try:
             return format(value, arg)
         except AttributeError:
@@ -722 +722 @@
         arg = settings.TIME_FORMAT
     try:
         return formats.time_format(value, arg)
-    except AttributeError:
+    except (AttributeError, UnicodeEncodeError):
         try:
             return dateformat.time_format(value, arg)
         except AttributeError:

django/utils/formats.py

@@ -7 +7 @@
 from django.utils.encoding import smart_str
 from django.utils import dateformat, numberformat, datetime_safe
 
+# format_cache is a mapping from (format_type, lang) to the format string.
+# By using the cache, it is possible to avoid running get_format_modules
+# repeatedly.
+_format_cache = {}
+
 def get_format_modules(reverse=False):
     """
     Returns an iterator over the format modules found in the project and Django
     """
+    lang = get_language()
     modules = []
-    if not check_for_language(get_language()) or not settings.USE_L10N:
+    if not check_for_language(lang) or not settings.USE_L10N:
         return modules
-    locale = to_locale(get_language())
+    locale = to_locale(lang)
     if settings.FORMAT_MODULE_PATH:
         format_locations = [settings.FORMAT_MODULE_PATH + '.%s']
     else:
@@ -40 +46 @@
     language (locale), defaults to the format in the settings.
     format_type is the name of the format, e.g. 'DATE_FORMAT'
     """
-    format_type = smart_str(format_type)
+    global _format_cache
     if settings.USE_L10N:
-        for module in get_format_modules():
-            try:
-                return getattr(module, format_type)
-            except AttributeError:
-                pass
+        lang = get_language()
+        try:
+            return _format_cache[(format_type, lang)] \
+                or getattr(settings, format_type)
+        except KeyError:
+            for module in get_format_modules():
+                try:
+                    val = getattr(module, format_type)
+                    _format_cache[(format_type, lang)] = val
+                    return val
+                except AttributeError:
+                    pass
+            _format_cache[(format_type, lang)] = None
     return getattr(settings, format_type)
 
 def date_format(value, format=None):

django/utils/numberformat.py

@@ -1 +1 @@
 from django.conf import settings
+from django.utils.safestring import mark_safe
+
 
 def format(number, decimal_sep, decimal_pos, grouping=0, thousand_sep=''):
     """
@@ -11 +13 @@
     * thousand_sep: Thousand separator symbol (for example ",")
 
     """
+    use_grouping = settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR \
+                   and grouping
+    # Make the common case fast:
+    if isinstance(number, int) and not use_grouping and not decimal_pos:
+        return mark_safe(unicode(number))
     # sign
     if float(number) < 0:
         sign = '-'
     else:
         sign = ''
-    # decimal part
     str_number = unicode(number)
     if str_number[0] == '-':
         str_number = str_number[1:]
+    # decimal part
     if '.' in str_number:
         int_part, dec_part = str_number.split('.')
         if decimal_pos:
@@ -30 +37 @@
         dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
     if dec_part: dec_part = decimal_sep + dec_part
     # grouping
-    if settings.USE_L10N and settings.USE_THOUSAND_SEPARATOR and grouping:
+    if use_grouping:
         int_part_gd = ''
         for cnt, digit in enumerate(int_part[::-1]):
             if cnt and not cnt % grouping:
                 int_part_gd += thousand_sep
             int_part_gd += digit
         int_part = int_part_gd[::-1]
-
     return sign + int_part + dec_part
 

django/utils/translation/__init__.py

@@ -20 +20 @@
 # replace the functions with their real counterparts (once we do access the
 # settings).
 
+# Cache the real translations provider in a global variable. Accessing settings
+# is slow in 1.2
+_trans_provider = None
+
 def delayed_loader(real_name, *args, **kwargs):
     """
     Call the real, underlying function.  We have a level of indirection here so
     that modules can use the translation bits without actually requiring
     Django's settings bits to be configured before import.
     """
-    from django.conf import settings
-    if settings.USE_I18N:
-        from django.utils.translation import trans_real as trans
-    else:
-        from django.utils.translation import trans_null as trans
+    global _trans_provider
+    if not _trans_provider:
+        from django.conf import settings
+        if settings.USE_I18N:
+            from django.utils.translation import trans_real as trans
+        else:
+            from django.utils.translation import trans_null as trans
+        _trans_provider = trans
 
     # Make the originally requested function call on the way out the door.
-    return getattr(trans, real_name)(*args, **kwargs)
+    return getattr(_trans_provider, real_name)(*args, **kwargs)
 
 g = globals()
 for name in __all__: