From 89896842de700c50b8a0983064c0647a3c36ab52 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Thu, 15 Jan 2009 04:00:46 +0000 Subject: Remove more unused stuff. --- repoze/bfg/functional.py | 136 ------------------------------ repoze/bfg/tests/test_chameleon_genshi.py | 2 - repoze/bfg/tests/test_chameleon_text.py | 2 - repoze/bfg/tests/test_chameleon_zpt.py | 2 - 4 files changed, 142 deletions(-) diff --git a/repoze/bfg/functional.py b/repoze/bfg/functional.py index 2b6fb6dbf..cf196ebd8 100644 --- a/repoze/bfg/functional.py +++ b/repoze/bfg/functional.py @@ -119,139 +119,3 @@ def wraps(wrapped, ### End from Python 2.5 functools.py ########################################## -def memoize(func, cache, num_args): - """ - Wrap a function so that results for any argument tuple are stored in - 'cache'. Note that the args to the function must be usable as dictionary - keys. - - Only the first num_args are considered when creating the key. - """ - def wrapper(*args): - mem_args = args[:num_args] - if mem_args in cache: - return cache[mem_args] - result = func(*args) - cache[mem_args] = result - return result - return wraps(func)(wrapper) - -class Promise(object): - """ - This is just a base class for the proxy class created in - the closure of the lazy function. It can be used to recognize - promises in code. - """ - pass - -def lazy(func, *resultclasses): - """ - Turns any callable 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. Results are not memoized; the - function is evaluated on every access. - """ - class __proxy__(Promise): - """ - Encapsulate a function call and act as a proxy for methods that are - called on the result of that function. The function is not evaluated - until one of the methods on the result is called. - """ - __dispatch = None - - def __init__(self, args, kw): - self.__func = func - self.__args = args - self.__kw = kw - if self.__dispatch is None: - self.__prepare_class__() - - def __prepare_class__(cls): - cls.__dispatch = {} - for resultclass in resultclasses: - cls.__dispatch[resultclass] = {} - for (k, v) in resultclass.__dict__.items(): - if hasattr(cls, k): - continue - setattr(cls, k, cls.__promise__(resultclass, k, v)) - cls._delegate_str = str in resultclasses - cls._delegate_unicode = unicode in resultclasses - assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types." - if cls._delegate_unicode: - cls.__unicode__ = cls.__unicode_cast - elif cls._delegate_str: - cls.__str__ = cls.__str_cast - __prepare_class__ = classmethod(__prepare_class__) - - def __promise__(cls, klass, funcname, func): - # Builds a wrapper around some magic method and registers that magic - # method for the given type and method name. - def __wrapper__(self, *args, **kw): - # Automatically triggers the evaluation of a lazy value and - # applies the given magic method of the result type. - res = self.__func(*self.__args, **self.__kw) - for t in type(res).mro(): - if t in self.__dispatch: - return self.__dispatch[t][funcname](res, *args, **kw) - raise TypeError("Lazy object returned unexpected type.") - - if klass not in cls.__dispatch: - cls.__dispatch[klass] = {} - cls.__dispatch[klass][funcname] = func - return __wrapper__ - __promise__ = classmethod(__promise__) - - def __unicode_cast(self): - return self.__func(*self.__args, **self.__kw) - - def __str_cast(self): - return str(self.__func(*self.__args, **self.__kw)) - - def __cmp__(self, rhs): - if self._delegate_str: - s = str(self.__func(*self.__args, **self.__kw)) - elif self._delegate_unicode: - s = unicode(self.__func(*self.__args, **self.__kw)) - else: - s = self.__func(*self.__args, **self.__kw) - if isinstance(rhs, Promise): - return -cmp(rhs, s) - else: - return cmp(s, rhs) - - def __mod__(self, rhs): - if self._delegate_str: - return str(self) % rhs - elif self._delegate_unicode: - return unicode(self) % rhs - else: - raise AssertionError('__mod__ not supported for non-string types') - - def __deepcopy__(self, memo): - # Instances of this class are effectively immutable. It's just a - # collection of functions. So we don't need to do anything - # complicated for copying. - memo[id(self)] = self - return self - - def __wrapper__(*args, **kw): - # Creates the proxy object, instead of the actual value. - return __proxy__(args, kw) - - return wraps(func)(__wrapper__) - -def allow_lazy(func, *resultclasses): - """ - A decorator that allows a function to be called with one or more lazy - arguments. If none of the args are lazy, the function is evaluated - immediately, otherwise a __proxy__ is returned that will evaluate the - function when needed. - """ - def wrapper(*args, **kwargs): - for arg in list(args) + kwargs.values(): - if isinstance(arg, Promise): - break - else: - return func(*args, **kwargs) - return lazy(func, *resultclasses)(*args, **kwargs) - return wraps(func)(wrapper) diff --git a/repoze/bfg/tests/test_chameleon_genshi.py b/repoze/bfg/tests/test_chameleon_genshi.py index 9b210e1ad..0833dc72f 100644 --- a/repoze/bfg/tests/test_chameleon_genshi.py +++ b/repoze/bfg/tests/test_chameleon_genshi.py @@ -139,8 +139,6 @@ class GetRendererTests(Base, unittest.TestCase): from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() - def implementation(self): - return self.template gsm = getGlobalSiteManager() utility = Dummy() gsm.registerUtility(utility, ITemplateRenderer, name='foo') diff --git a/repoze/bfg/tests/test_chameleon_text.py b/repoze/bfg/tests/test_chameleon_text.py index 992957d0e..49e07a79d 100644 --- a/repoze/bfg/tests/test_chameleon_text.py +++ b/repoze/bfg/tests/test_chameleon_text.py @@ -145,8 +145,6 @@ class GetRendererTests(Base, unittest.TestCase): from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() - def implementation(self): - return self.template gsm = getGlobalSiteManager() utility = Dummy() gsm.registerUtility(utility, ITemplateRenderer, name='foo') diff --git a/repoze/bfg/tests/test_chameleon_zpt.py b/repoze/bfg/tests/test_chameleon_zpt.py index 088930069..bd2c67cc9 100644 --- a/repoze/bfg/tests/test_chameleon_zpt.py +++ b/repoze/bfg/tests/test_chameleon_zpt.py @@ -142,8 +142,6 @@ class GetRendererTests(Base, unittest.TestCase): from repoze.bfg.interfaces import ITemplateRenderer class Dummy: template = object() - def implementation(self): - return self.template gsm = getGlobalSiteManager() utility = Dummy() gsm.registerUtility(utility, ITemplateRenderer, name='foo') -- cgit v1.2.3