human
Complete this python program:
def addClassAdvisor(callback, depth=2):
assistant
#Here is the Python code you requested.

    """Set up \callback\ to be passed the containing class upon creation
    This function is designed to be called by an "advising" function executed
    in a class suite.  The "advising" function supplies a callback that it
    wishes to have executed when the containing class is created.  The
    callback will be given one argument: the newly created containing class.
    The return value of the callback will be used in place of the class, so
    the callback should return the input if it does not wish to replace the
    class.
    The optional \depth\ argument to this function determines the number of
    frames between this function and the targeted class suite.  \depth\
    defaults to 2, since this skips this function\s frame and one calling
    function frame.  If you use this function from a function called directly
    in the class suite, the default will be correct, otherwise you will need
    to determine the correct depth yourself.
    This function works by installing a special class factory function in
    place of the \__metaclass__\ of the containing class.  Therefore, only
    callbacks *after* the last \__metaclass__\ assignment in the containing
    class will be executed.  Be sure that classes using "advising" functions
    declare any \__metaclass__\ *first*, to ensure all callbacks are run.
    """
    frame = sys._getframe(depth)
    (kind, module, caller_locals, caller_globals) = getFrameInfo(frame)
    previousMetaclass = caller_locals.get('__metaclass__')
    if __python3:
        defaultMetaclass = caller_globals.get('__metaclass__', type)
    else:
        defaultMetaclass = caller_globals.get('__metaclass__', ClassType)
    def advise(name, bases, cdict):
        if ('__metaclass__' in cdict):
            del cdict['__metaclass__']
        if (previousMetaclass is None):
            if bases:
                meta = determineMetaclass(bases)
            else:
                meta = defaultMetaclass
        elif isClassAdvisor(previousMetaclass):
            meta = previousMetaclass
        else:
            meta = determineMetaclass(bases, previousMetaclass)
        newClass = meta(name, bases, cdict)
        return callback(newClass)
    advise.previousMetaclass = previousMetaclass
    advise.callback = callback
    caller_locals['__metaclass__'] = advise