Come gestire i passaggi aggiuntivi che fanno parte della classe concreta genericamente nel modello di progettazione del modello di modello?

Ho una serie di operazioni che devono essere eseguite come parte di un processo di grandi dimensioni e le sottoclassi possono leggermente differire in parte del passo. Questo problema sembra essere risolto utilizzando il metodo di modello del modello di progettazione, quindi ho qualcosa di simile in basso.

class BaseTemplate(object):
    def perform(self)
        self.disable()
        self.update()
        self.enable()

    def disable(self):
        # Generic behavior

    def update(self):
        # Generic behavior

    def enable(self)
        # Generic behavior

class FooTemplate(BaseTemplate):
    def enable(self):
       # Foo-specific behavior

    def update(self):
       # Foo-specific behavior

class BarTemplate(BaseTemplate):
    def update(self):
       # Bar-specific behavior

Tuttavia, il problema con update() è che i modelli concreti hanno solo bisogno di qualche passo in più su quello che ha fatto la classe base.

Ad esempio,

BaseTemplate

def update():
    # Get X
    # Set field A of X
    # Set field B of X

FooTemplate

def update():
    # Get Y (Y is a subclass of X)
    # Set field A of Y
    # Set field B of Y
    # Set field C of Y (Field C is specific to Y which is a subclass of X)

Il problema è che l'impostazione del campo di A e B è duplicata come mostrato sopra, quindi potrei fare qualcosa di simile in FooTemplate

def update():
    super(FooTemplate, self).update() # Handles fields A and B
    # Set field C

Tuttavia, il metodo delle super classi è un metodo anti-pattern Chiama Super poiché tutte le sottoclassi '% co_de' % deve chiamare update() altrimenti si interromperà.

Quindi, un approccio diverso sarebbe avere un metodo no-op che imposta il campo super.update() nella classe base e quindi implementare le sottoclassi dei template solo quando necessario. Tuttavia, questo approccio sembra violare il campo di aggiornamento OOP C è richiesto solo da C e altre sottoclassi di FooTemplate non dovrebbero saperlo.

Domande:

1. È corretto utilizzare il modello di metodo del modello per il mio utilizzo?
2. Come gestire BaseTemplate che aggiunge passaggi aggiuntivi mentre i modelli diventano concreti in un modo OOP?
3. Qualche suggerimento in generale?