Template Method

abstract class ImportadorRelatorio {
  // O template method: a ordem e final, ninguem sobrescreve
  importar(caminho: string): number {
    const linhas = this.ler(caminho);
    const validas = this.validar(linhas);
    this.gravar(validas);
    this.aoTerminar(validas.length); // gancho opcional
    return validas.length;
  }

  // passos obrigatorios: cada formato le e grava do seu jeito
  protected abstract ler(caminho: string): string[];
  protected abstract gravar(linhas: string[]): void;

  // passo com padrao razoavel: a subclasse sobrescreve se quiser
  protected validar(linhas: string[]): string[] {
    return linhas.filter((l) => l.trim().length > 0);
  }

  // gancho: nao faz nada por padrao
  protected aoTerminar(_total: number): void {}
}

class ImportadorCSV extends ImportadorRelatorio {
  protected ler(caminho: string): string[] {
    return ["a,1", "b,2"]; // leria o arquivo
  }
  protected gravar(linhas: string[]): void {
    console.log("gravando", linhas.length, "linhas");
  }
}

new ImportadorCSV().importar("vendas.csv");

from abc import ABC, abstractmethod

class ImportadorRelatorio(ABC):
    # O template method: a ordem e fixa
    def importar(self, caminho):
        linhas = self.ler(caminho)
        validas = self.validar(linhas)
        self.gravar(validas)
        self.ao_terminar(len(validas))  # gancho opcional
        return len(validas)

    # passos obrigatorios
    @abstractmethod
    def ler(self, caminho): ...
    @abstractmethod
    def gravar(self, linhas): ...

    # passo com padrao razoavel
    def validar(self, linhas):
        return [l for l in linhas if l.strip()]

    # gancho: nao faz nada por padrao
    def ao_terminar(self, total):
        pass

class ImportadorCSV(ImportadorRelatorio):
    def ler(self, caminho):
        return ["a,1", "b,2"]

    def gravar(self, linhas):
        print("gravando", len(linhas), "linhas")

ImportadorCSV().importar("vendas.csv")