Changeset 884

Timestamp:

10/16/05 11:10:48 (3 years ago)

Author:

hugo

Message:

i18n: added gettext_lazy - lazy translation for stuff like model help text

Files:

• django/branches/i18n/django/bin/make-messages.py (modified) (1 diff)
• django/branches/i18n/django/utils/functional.py (modified) (1 diff)
• django/branches/i18n/django/utils/translation.py (modified) (2 diffs)

django/branches/i18n/django/bin/make-messages.py

@@ -76 +76 @@
-                thefile = '%s.py' % file
-            if verbose: sys.stdout.write('processing file %s in %s\n' % (file, dirpath))
-
+-keyword=gettext_lazy --keyword=ngettext_lazy -
-                os.path.exists(potfile) and '--omit-header' or '', domain, os.path.join(dirpath, thefile))
-            msgs = os.popen(cmd, 'r').read()

django/branches/i18n/django/utils/functional.py

@@ -3 +3 @@
-        return args[0](*(args[1:]+moreargs), **dict(kwargs.items() + morekwargs.items()))
-    return _curried
+
+class NoneSoFar:
+    """
+    NoneSoFar is a singleton that denotes a missing value. This can be
+    used instead of None - because None might be a valid return value.
+    """
+    pass
+NoneSoFar = NoneSoFar()
+
+def force(value):
+    """
+    This function forces evaluation of a promise. It recognizes a promise
+    by it's magic __force__ function and just applies it and returns
+    the result. If the value isn't a promise, it just returns the value.
+    """
+
+    return getattr(value, '__force__', lambda : value)()
+
+def forced(value):
+    """
+    This function returns true if a value is either not a promise or
+    is already forced. This uses the __forced__ magic method.
+    """
+    return getattr(value, '__forced__', lambda : True)()
+
+def lazy(func, *resultclasses):
+
+    """
+    lazy turns any callable passed in into a lazy evaluated callable.
+    you need to give result classes or types - at least one is needed
+    so that the automatic forcing of the lazy evaluation code is
+    triggered.
+    """
+
+    class __proxy__:
+    
+        """
+        This inner class encapsulates the code that should be evaluated
+        lazyly. On calling of one of the magic methods it will force
+        the evaluation and store the result - afterwards the result
+        is delivered directly. So the result is memoized.
+        """
+
+        def __init__(self, args, kw):
+           self.__func = func
+           self.__args = args
+           self.__kw = kw
+           self.__result = NoneSoFar
+           self.__dispatch = {}
+           for resultclass in resultclasses:
+               self.__dispatch[resultclass] = {}
+               for (k, v) in resultclass.__dict__.items():
+                   setattr(self, k, self.__promise__(resultclass, k, v))
+        
+        def __force__(self):
+           """
+           This function forces the evaluation of a promise and
+           returns the value itself.
+           """
+           if self.__result is NoneSoFar:
+              self.__result = self.__func(*self.__args, **self.__kw)
+           return self.__result
+        
+        def __forced__(self):
+           """
+           This returns true if the promise is forced and false if not.
+           """
+           if self.__result is NoneSoFar: return False
+           else: return True
+  
+        def __promise__(self, klass, funcname, func):
+        
+           """
+           This function builds a wrapper around some magic method and
+           registers that magic method for the given type and methodname.
+           """
+    
+           def __wrapper__(*args, **kw):
+              """
+              This wrapper function automatically forces the evaluation of
+              a lazy value if the value isn't already forced. It then applies
+              the given magic method of the result type.
+              """
+              res = self.__force__()
+              return self.__dispatch[type(res)][funcname](res, *args, **kw)
+  
+           if not self.__dispatch.has_key(klass): self.__dispatch[klass] = {}
+           self.__dispatch[klass][funcname] = func
+           return __wrapper__
+  
+    def __wrapper__(*args, **kw):
+        """
+        This wrapper function just creates the proxy object that is returned
+        instead of the actual value.
+        """
+        return __proxy__(args, kw)
+
+    return __wrapper__
+
+if __name__ == '__main__':
+    def anton(a,b):
+        return a+b
+
+    anton = lazy(anton, int, str)
+
+    print type(anton(5,6))
+    print anton(5,6)
+    print anton('anton','berta')
+    print type(force(anton(5,6)))
+    print forced(1)
+    print forced(anton(5,6))
+    print forced(force(anton(5,6)))
+

django/branches/i18n/django/utils/translation.py

@@ -4 +4 @@
-import sys
-import gettext as gettext_module
+
+from django.utils.functional import lazy
-
-try:
@@ -229 +231 @@
-        _default = translation('*', settings.LANGUAGE_CODE)
-    return _default.ngettext(singular, plural, number)
+
+gettext_lazy = lazy(gettext, str)
+ngettext_lazy = lazy(ngettext, str)
-
-def get_language_from_request(request):