class PrototypeException(Exception):

pass

class PrototypeSwitcher(object):

def __init__(self, delegate, extend=False):

self._delegate = delegate

self._replacement = None

self._extend = extend

def _delegate_call(self, key):

def delegator(eat_self, *args, **kwargs):

bound_fn = getattr(self._delegate, key)

if bound_fn:

return bound_fn(*args, **kwargs)

return delegator

def _decorate(self, cls):

old_getattr = getattr(cls, '__getattr__', None)

delegate_bind = self._delegate #for speed

def __getattr__(self, name):

if old_getattr:

try:

return old_getattr(self, name)

except AttributeError:

pass

return getattr(delegate_bind, name)

cls.__getattr__ = __getattr__

cls.__call__ = self._delegate_call('__call__')

return cls

@property

def new(self):

if not self._replacement:

@self._decorate

class PrototypeChild(object):

pass

self._replacement = PrototypeChild()

return self._replacement

def __call__(self, cls):

if getattr(self._delegate, '__call__', False) and not self._extend:

raise PrototypeException("You attempted to use a prototype as a decorator, but the object you're extending already has a __call__ method. You will need to explicitly use the .extend syntax like this: @prototype(obj, True) in this case. You will see this error on multi-level prototypes")

return self._decorate(cls)

def __getattr__(self, name):

if getattr(self._delegate, 'new', False):

raise PrototypeException("You are using a raw prototype as a clone, but the parent defined a new attribute. You must explicitly instantiate using @prototype(obj).new in this case. You will see this error on multi-level prototypes.")

return getattr(self.new, name)

def prototype(delegate, extend=False):

"""

Implement javascript prototypal inheritance in python. This

implementation will allow you to create new prototypes on the fly,

or set prototypes for classes.

Usage:

You can use it to make lightweight children from an existing object.

obj = Parent()

obj_child = prototype(obj)

You can use it to make static prototypes for classes.

obj = Parent()

@prototype(obj)

class Child(object):

pass

obj2 = Child()

In some rare cases you must explicitly force a clone or a

decorator to be created. If the object contains a `new` property

you must explicitly call .new to force a clone to be made.

obj = Parent()

obj.new = 1

obj_child = prototype(obj).new

If the object contains a `__call__` property, you must explicitly

create a decorator with the extend=True keyword argument.

obj = Parent()

obj.__call__ = 1

@prototype(obj, extend=True)

class Child(object):

pass

Prototypes can extend prototypes as many levels as you want. One note,

prototypes extending prototypes must use .new and extend=True.

obj = Parent()

child = prototype(obj)

grandchild = prototype(child).new

"""

return PrototypeSwitcher(delegate, extend)