Django

Code

Changeset 8127

Show
Ignore:
Timestamp:
07/27/08 19:45:04 (4 months ago)
Author:
mtredinnick
Message:

Put back [8120] along with a small tweak. Fixed #6217.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/trunk/AUTHORS

    r8126 r8127  
    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

    r8126 r8127  
    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

    r8126 r8127  
    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. 
    180188                res = self.__func(*self.__args, **self.__kw) 
    181                 return self.__dispatch[type(res)][funcname](res, *args, **kw) 
    182  
    183             if klass not in self.__dispatch: 
    184                 self.__dispatch[klass] = {} 
    185             self.__dispatch[klass][funcname] = func 
     189                for t in type(res).mro(): 
     190                    if t in self.__dispatch: 
     191                        return self.__dispatch[t][funcname](res, *args, **kw) 
     192                raise TypeError("Lazy object returned unexpected type.") 
     193 
     194            if klass not in cls.__dispatch: 
     195                cls.__dispatch[klass] = {} 
     196            cls.__dispatch[klass][funcname] = func 
    186197            return __wrapper__ 
     198        __promise__ = classmethod(__promise__) 
    187199 
    188200        def __unicode_cast(self):