speaklater-1.3/0000755000076500000240000000000011774072126014656 5ustar mitsuhikostaff00000000000000speaklater-1.3/LICENSE0000644000076500000240000000272511456610115015662 0ustar mitsuhikostaff00000000000000Copyright (c) 2009 by Armin Ronacher. Some rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. speaklater-1.3/PKG-INFO0000644000076500000240000000526111774072126015757 0ustar mitsuhikostaff00000000000000Metadata-Version: 1.0 Name: speaklater Version: 1.3 Summary: implements a lazy string for python useful for use with gettext Home-page: http://github.com/mitsuhiko/speaklater Author: Armin Ronacher Author-email: armin.ronacher@active-4.com License: UNKNOWN Description: speaklater ~~~~~~~~~~ A module that provides lazy strings for translations. Basically you get an object that appears to be a string but changes the value every time the value is evaluated based on a callable you provide. For example you can have a global `lazy_gettext` function that returns a lazy string with the value of the current set language. Example: >>> from speaklater import make_lazy_string >>> sval = u'Hello World' >>> string = make_lazy_string(lambda: sval) This lazy string will evaluate to the value of the `sval` variable. >>> string lu'Hello World' >>> unicode(string) u'Hello World' >>> string.upper() u'HELLO WORLD' If you change the value, the lazy string will change as well: >>> sval = u'Hallo Welt' >>> string.upper() u'HALLO WELT' This is especially handy when combined with a thread local and gettext translations or dicts of translatable strings: >>> from speaklater import make_lazy_gettext >>> from threading import local >>> l = local() >>> l.translations = {u'Yes': 'Ja'} >>> lazy_gettext = make_lazy_gettext(lambda: l.translations.get) >>> yes = lazy_gettext(u'Yes') >>> print yes Ja >>> l.translations[u'Yes'] = u'Si' >>> print yes Si Lazy strings are no real strings so if you pass this sort of string to a function that performs an instance check, it will fail. In that case you have to explicitly convert it with `unicode` and/or `string` depending on what string type the lazy string encapsulates. To check if a string is lazy, you can use the `is_lazy_string` function: >>> from speaklater import is_lazy_string >>> is_lazy_string(u'yes') False >>> is_lazy_string(yes) True New in version 1.2: It's now also possible to pass keyword arguments to the callback used with `make_lazy_string`. Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: License :: OSI Approved :: BSD License Classifier: Topic :: Software Development :: Internationalization Classifier: Programming Language :: Python speaklater-1.3/README0000644000076500000240000000030711456610304015527 0ustar mitsuhikostaff00000000000000A module that provides lazy strings for translations. Basically you get an object that appears to be a string but changes the value every time the value is evaluated based on a callable you provide. speaklater-1.3/setup.py0000644000076500000240000000215511774072105016370 0ustar mitsuhikostaff00000000000000import os try: from setuptools import setup except ImportError: from distutils.core import setup def get_docs(): result = [] in_docs = False f = open(os.path.join(os.path.dirname(__file__), 'speaklater.py')) try: for line in f: if in_docs: if line.lstrip().startswith(':copyright:'): break result.append(line[4:].rstrip()) elif line.strip() == 'r"""': in_docs = True finally: f.close() return '\n'.join(result) setup( name='speaklater', author='Armin Ronacher', author_email='armin.ronacher@active-4.com', version='1.3', url='http://github.com/mitsuhiko/speaklater', py_modules=['speaklater'], description='implements a lazy string for python useful for use with gettext', long_description=get_docs(), zip_safe=False, classifiers=[ 'Development Status :: 5 - Production/Stable', 'License :: OSI Approved :: BSD License', 'Topic :: Software Development :: Internationalization', 'Programming Language :: Python' ] ) speaklater-1.3/speaklater.py0000644000076500000240000001214011456610115017352 0ustar mitsuhikostaff00000000000000# -*- coding: utf-8 -*- r""" speaklater ~~~~~~~~~~ A module that provides lazy strings for translations. Basically you get an object that appears to be a string but changes the value every time the value is evaluated based on a callable you provide. For example you can have a global `lazy_gettext` function that returns a lazy string with the value of the current set language. Example: >>> from speaklater import make_lazy_string >>> sval = u'Hello World' >>> string = make_lazy_string(lambda: sval) This lazy string will evaluate to the value of the `sval` variable. >>> string lu'Hello World' >>> unicode(string) u'Hello World' >>> string.upper() u'HELLO WORLD' If you change the value, the lazy string will change as well: >>> sval = u'Hallo Welt' >>> string.upper() u'HALLO WELT' This is especially handy when combined with a thread local and gettext translations or dicts of translatable strings: >>> from speaklater import make_lazy_gettext >>> from threading import local >>> l = local() >>> l.translations = {u'Yes': 'Ja'} >>> lazy_gettext = make_lazy_gettext(lambda: l.translations.get) >>> yes = lazy_gettext(u'Yes') >>> print yes Ja >>> l.translations[u'Yes'] = u'Si' >>> print yes Si Lazy strings are no real strings so if you pass this sort of string to a function that performs an instance check, it will fail. In that case you have to explicitly convert it with `unicode` and/or `string` depending on what string type the lazy string encapsulates. To check if a string is lazy, you can use the `is_lazy_string` function: >>> from speaklater import is_lazy_string >>> is_lazy_string(u'yes') False >>> is_lazy_string(yes) True New in version 1.2: It's now also possible to pass keyword arguments to the callback used with `make_lazy_string`. :copyright: (c) 2010 by Armin Ronacher. :license: BSD, see LICENSE for more details. """ def is_lazy_string(obj): """Checks if the given object is a lazy string.""" return isinstance(obj, _LazyString) def make_lazy_string(__func, *args, **kwargs): """Creates a lazy string by invoking func with args.""" return _LazyString(__func, args, kwargs) def make_lazy_gettext(lookup_func): """Creates a lazy gettext function dispatches to a gettext function as returned by `lookup_func`. Example: >>> translations = {u'Yes': u'Ja'} >>> lazy_gettext = make_lazy_gettext(lambda: translations.get) >>> x = lazy_gettext(u'Yes') >>> x lu'Ja' >>> translations[u'Yes'] = u'Si' >>> x lu'Si' """ def lazy_gettext(string): if is_lazy_string(string): return string return make_lazy_string(lookup_func(), string) return lazy_gettext class _LazyString(object): """Class for strings created by a function call. The proxy implementation attempts to be as complete as possible, so that the lazy objects should mostly work as expected, for example for sorting. """ __slots__ = ('_func', '_args', '_kwargs') def __init__(self, func, args, kwargs): self._func = func self._args = args self._kwargs = kwargs value = property(lambda x: x._func(*x._args, **x._kwargs)) def __contains__(self, key): return key in self.value def __nonzero__(self): return bool(self.value) def __dir__(self): return dir(unicode) def __iter__(self): return iter(self.value) def __len__(self): return len(self.value) def __str__(self): return str(self.value) def __unicode__(self): return unicode(self.value) def __add__(self, other): return self.value + other def __radd__(self, other): return other + self.value def __mod__(self, other): return self.value % other def __rmod__(self, other): return other % self.value def __mul__(self, other): return self.value * other def __rmul__(self, other): return other * self.value def __lt__(self, other): return self.value < other def __le__(self, other): return self.value <= other def __eq__(self, other): return self.value == other def __ne__(self, other): return self.value != other def __gt__(self, other): return self.value > other def __ge__(self, other): return self.value >= other def __getattr__(self, name): if name == '__members__': return self.__dir__() return getattr(self.value, name) def __getstate__(self): return self._func, self._args, self._kwargs def __setstate__(self, tup): self._func, self._args, self._kwargs = tup def __getitem__(self, key): return self.value[key] def __copy__(self): return self def __repr__(self): try: return 'l' + repr(self.value) except Exception: return '<%s broken>' % self.__class__.__name__ if __name__ == '__main__': import doctest doctest.testmod()