In somehow related news, I have discovered that my search-foo is not good enough, when I was unable to find a decent implementations of several design patterns in Python.
What I needed was a generic proxy that would defer initialisation of an object to the moment it is first used. Here is what I came up with:
class LazyProxy(object): __slots__ = '__get' def __init__(self, cls, *args, **kw): object.__setattr__(self, '_LazyProxy__get', lambda: self.__set(cls(*args, **kw))) def __set(self, obj): object.__setattr__(self, '_LazyProxy__get', lambda: obj) return obj def __getattr__(self, name): return getattr(self.__get(), name) def __setattr__(self, name, value): return setattr(self.__get(), name, value) def __delattr__(self, name): return delattr(self.__get(), name)
Here’s how one can use it:
class Foo(object): foo = 'foo' def __init__(self, bar, baz): print 'Creating Foo...' self.foo = 'foobar' self.bar = bar self.baz = baz def a(self): print 'Foo.a: self=(foo=%s, bar=%s, baz=%s)' % ( self.foo, self.bar, self.baz) @classmethod def b(cls): print 'Foo.b: cls=%s, cls.foo=%s' % ( cls.__name__, cls.foo) @staticmethod def c(): print 'Foo.c' foo = LazyProxy(Foo, 'bar', baz='qux') print 'LazyProxy created' foo.a() foo.b() foo.c()
foo can be used in (almost) the same way as an already created
Foo object would. The only caveat is it will not be an instance of
Foo which may or may not be an issue. Also, it is not thread safe.
Code © Google Inc.