Django

Code

Changeset 8120

Show
Ignore:
Timestamp:
07/27/08 17:51:49 (4 months ago)
Author:
mtredinnick
Message:

Fixed #6217 -- Reduced the memory used by each ugettext_lazy() call.
Thanks to Jakub Wilk for analysis and the initial patch.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/AUTHORS

    r8113 r8120  
    408408    Rachel Willmer <http://www.willmer.com/kb/> 
    409409    Gary Wilson <gary.wilson@gmail.com> 
     410    Jakub Wilk <ubanus@users.sf.net> 
    410411    Jakub Wiśniowski <restless.being@gmail.com> 
    411412    Maciej Wiśniowski <pigletto@gmail.com> 

  • django/trunk/django/db/models/fields/__init__.py

    r8102 r8120  
    192192        self.name = name 
    193193        self.attname, self.column = self.get_attname_column() 
    194         self.verbose_name = self.verbose_name or (name and name.replace('_', ' ')) 
     194        if self.verbose_name is None and name: 
     195            self.verbose_name = name.replace('_', ' ') 
    195196 
    196197    def contribute_to_class(self, cls, name): 

  • django/trunk/django/utils/functional.py

    r7153 r8120  
    149149    """ 
    150150    class __proxy__(Promise): 
    151         # This inner class encapsulates the code that should be evaluated 
    152         # lazily. On calling of one of the magic methods it will force 
    153         # the evaluation and store the result. Afterwards, the result 
    154         # is delivered directly. So the result is memoized. 
     151        """ 
     152        Encapsulate a function call and act as a proxy for methods that are 
     153        called on the result of that function. The function is not evaluated 
     154        until one of the methods on the result is called. 
     155        """ 
     156        __dispatch = None 
     157 
    155158        def __init__(self, args, kw): 
    156159            self.__func = func 
    157160            self.__args = args 
    158161            self.__kw = kw 
    159             self.__dispatch = {} 
     162            if self.__dispatch is None: 
     163                self.__prepare_class__() 
     164 
     165        def __prepare_class__(cls): 
     166            cls.__dispatch = {} 
    160167            for resultclass in resultclasses: 
    161                 self.__dispatch[resultclass] = {} 
     168                cls.__dispatch[resultclass] = {} 
    162169                for (k, v) in resultclass.__dict__.items(): 
    163                     setattr(self, k, self.__promise__(resultclass, k, v)) 
    164             self._delegate_str = str in resultclasses 
    165             self._delegate_unicode = unicode in resultclasses 
    166             assert not (self._delegate_str and self._delegate_unicode), "Cannot call lazy() with both str and unicode return types." 
    167             if self._delegate_unicode: 
    168                 # Each call to lazy() makes a new __proxy__ object, so this 
    169                 # doesn't interfere with any other lazy() results. 
    170                 __proxy__.__unicode__ = __proxy__.__unicode_cast 
    171             elif self._delegate_str: 
    172                 __proxy__.__str__ = __proxy__.__str_cast 
    173  
    174         def __promise__(self, klass, funcname, func): 
     170                    if hasattr(cls, k): 
     171                        continue 
     172                    setattr(cls, k, cls.__promise__(resultclass, k, v)) 
     173            cls._delegate_str = str in resultclasses 
     174            cls._delegate_unicode = unicode in resultclasses 
     175            assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types." 
     176            if cls._delegate_unicode: 
     177                cls.__unicode__ = cls.__unicode_cast 
     178            elif cls._delegate_str: 
     179                cls.__str__ = cls.__str_cast 
     180        __prepare_class__ = classmethod(__prepare_class__) 
     181 
     182        def __promise__(cls, klass, funcname, func): 
    175183            # Builds a wrapper around some magic method and registers that magic 
    176184            # method for the given type and method name. 
    177             def __wrapper__(*args, **kw): 
     185            def __wrapper__(self, *args, **kw): 
    178186                # Automatically triggers the evaluation of a lazy value and 
    179187                # applies the given magic method of the result type. 
    …… 
    181189                return self.__dispatch[type(res)][funcname](res, *args, **kw) 
    182190 
    183             if klass not in self.__dispatch: 
    184                 self.__dispatch[klass] = {} 
    185             self.__dispatch[klass][funcname] = func 
     191            if klass not in cls.__dispatch: 
     192                cls.__dispatch[klass] = {} 
     193            cls.__dispatch[klass][funcname] = func 
    186194            return __wrapper__ 
     195        __promise__ = classmethod(__promise__) 
    187196 
    188197        def __unicode_cast(self):