"""Module for partial classes.

To declare a class partial, inherit from partial.partial and from
the full class, like so

from partial import partial
import original_module

class ExtendedClass(partial, original_module.FullClass):
    def additional_method(self, args):
        body
    more_methods

After this class definition is executed, original_method.FullClass
will have all the additional properties defined in ExtendedClass;
the name ExtendedClass is of no importance (and becomes an alias
for FullClass).
It is an error if the original class already contains the 
definitions being added, unless they are methods declared
with @replace.
"""

class _MetaPartial(type):
    "Metaclass implementing the hook for partial class definitions."

    def __new__(cls, name, bases, dict):
        if not bases:
            # It is the class partial itself
            return type.__new__(cls, name, bases, dict)
        if len(bases) != 2:
            raise TypeError, "A partial class definition must have only one base class to extend"
        base = bases[1]
        for k, v in dict.items():
            if k == '__module__':
                # Ignore implicit attribute
                continue
            if k in base.__dict__:
                if hasattr(v, '__noreplace'):
                    continue
                if not hasattr(v, '__replace'):
                    raise TypeError, "%s already has %s" % (repr(base), k)
            setattr(base, k, v)
        # Return the original class
        return base

class partial:
    "Base class to declare partial classes. See module docstring for details."
    __metaclass__ = _MetaPartial

def replace(f):
    """Method decorator to indicate that a method shall replace 
    the method in the full class."""
    f.__replace = True
    return f

def noreplace(f):
    """Method decorator to indicate that a method definition shall
    silently be ignored if it already exists in the full class."""
    f.__noreplace = True
    return f