¿Cómo llamar al método original cuando está parchado?

Question

Tengo una clase en el proyecto principal que no quiero cambiar.

class A(): 
    def __init__(self, firstname, lastname): 
     self.firstname = firstname 
     self.lastname = lastname 

    def name(self): 
     # this method could be much more complex 
     return self.lastname.upper() 

Estoy intentando construir un plugin mechansim. Hasta aquí todo bien, tengo un punto de extensión de esta manera:

if __name__ == '__main__': 
    ''' The main project has an extension point that allows me to do''' 
    # for each class extension such as AExtended: 
    A.name = AExtended.name 
    ''' After the extensions are loaded, some behaviours may be changed''' 
    a = A("John", "Doe") 
    print(a.name()) 

Un plugin se puede escribir así:

class AExtended(A): 
    ''' This is an extension I provide through a plugin mechanism 
    ''' 
    def name(self): 
     return self.firstname + ' ' + self.lastname.upper() 

Todo esto funciona muy bien. Ahora obtengo "John DOE".

Mi problema es que el método original name() puede ser bastante complejo. En otras palabras, no puedo darme el lujo de llamar al self.lastname.upper() en el AExtended. Me gustaría llamar al método "super", que ya no existe, porque ha sido sobrescrito.

¿Cómo puedo cambiar mi código, a fin de lograr algo como esto:

class AExtended(A): 
    def name(self): 
     # I'm looking for a way to call the base implementation that was in A.name() 
     return self.firstname + ' ' + parent.name() 

Gracias por su ayuda!

Editar: Algunas explicaciones de lo que intento hacer.

• Quiero que el complemento parchee el comportamiento de A. No me puedo permitir a los consumidores cambiar existentes de un
• Hay muchas clases como A que se podrían cambiar, me gustaría plugins para tener un control total y la responsabilidad
• Es cierto AExtended no tiene que heredar de A, pero fue una manera fácil de acceder al self.firstname. No tengo problemas para seguir un patrón de diseño diferente si puede ayudar.

tengo una solución, pero no es muy elegante y difícil generalizar

class AExtended(A): 
    def name(self): 
     # I'm looking for a way to call the base implementation that was in A.name() 
     return self.firstname + ' ' + self.parentname() 
#in main 
A.parentname = A.name 
A.name = AExtended.name 

Answer 1

Aquí hay un ejemplo completo de lo que estaba insinuando. Siéntase libre de gritarme y hacerme fusionar mis respuestas, o rechazar una o más, simplemente es más fácil ofrecer una alternativa como una nueva respuesta. Dejaré que el código hable en lugar de explicarlo mal.:)

## Some shared class that is used all over the place and needs to be patched. 

class A(object): 
    def __init__(self): 
     self.firstname = 'Bob' 

    # Print my first name. 
    def name(self): 
     return self.firstname 

    # Use this to allow patching arbitrary methods... 
    @classmethod 
    def patch(cls, func_name): 
     def patch_by_name(new_func): 
      old_func = getattr(cls, func_name) 
      def patched_func(self): 
       return new_func(self, old_func) 
      setattr(cls, func_name, patched_func) 
     return patch_by_name 

## Some other area of the code where you want to throw in a patch 

class PatchedA(A): # doesn't need to subclass, but comes in handy sometimes 
    @A.patch('name') 
    def name(self, orig_func): 
     return 'I am ' + orig_func(self) + 'McWizwaz' 

print 'Who are you, A class?' 
print A().name() # prints 'I am Bob McWizwaz' 

Answer 2

Una opción que no siempre podría ser el mejor en un lenguaje como Python es usar el decorador @override de this non-standard package. Pero esta es una opción viable solo si sus dos funciones funcionan en diferentes tipos o diferentes números de argumentos. Aparte de eso, no hay mucho que puedas hacer, además de cambiar el nombre de tu función.

Answer 3

class ABase(object): 
    def name(self): 
     pass 

class A(object): 
    pass 

class AExtension(ABase): 
    def name(self): 
     return ABase.name(self) 

A.name = AExtension.name 

Answer 4

Esto es lo que llamamos un patrón de 'decorador'. Reemplace la reasignación original del nombre para que llame a una función, que toma el original. Luego devuelve una nueva función.

def name_decorator(method): 
    def decorate_name(self=None): 
     return stuff + method(self) 
    return decorate_name 
A.name = name_decorator(A.name) 

Más tarde, llamando A.name llamará decorate_name con self como la instancia actual y method estará disponible a lo que apunta a la función en el momento de la reasignación.