Command

interface Comando {
  executar(): void;
  desfazer(): void;
}

class Documento {
  texto = "";
}

// A acao vira objeto: carrega os dados que ela precisa para se desfazer
class ColarTexto implements Comando {
  constructor(
    private doc: Documento,
    private trecho: string,
    private posicao: number,
  ) {}

  executar(): void {
    const d = this.doc;
    d.texto = d.texto.slice(0, this.posicao) + this.trecho + d.texto.slice(this.posicao);
  }

  desfazer(): void {
    const d = this.doc;
    d.texto = d.texto.slice(0, this.posicao) + d.texto.slice(this.posicao + this.trecho.length);
  }
}

// O invocador nao conhece nenhum comando concreto
class Historico {
  private pilha: Comando[] = [];

  executar(cmd: Comando): void {
    cmd.executar();
    this.pilha.push(cmd);
  }

  desfazer(): void {
    this.pilha.pop()?.desfazer();
  }
}

const doc = new Documento();
const h = new Historico();
h.executar(new ColarTexto(doc, "olá", 0));
h.desfazer(); // volta ao estado anterior

from abc import ABC, abstractmethod

class Comando(ABC):
    @abstractmethod
    def executar(self): ...
    @abstractmethod
    def desfazer(self): ...

class Documento:
    def __init__(self):
        self.texto = ""

# A acao vira objeto: guarda o que precisa para se desfazer
class ColarTexto(Comando):
    def __init__(self, doc, trecho, posicao):
        self._doc, self._trecho, self._pos = doc, trecho, posicao

    def executar(self):
        d = self._doc
        d.texto = d.texto[: self._pos] + self._trecho + d.texto[self._pos :]

    def desfazer(self):
        d = self._doc
        fim = self._pos + len(self._trecho)
        d.texto = d.texto[: self._pos] + d.texto[fim:]

# O invocador nao conhece nenhum comando concreto
class Historico:
    def __init__(self):
        self._pilha = []

    def executar(self, cmd):
        cmd.executar()
        self._pilha.append(cmd)

    def desfazer(self):
        if self._pilha:
            self._pilha.pop().desfazer()

doc, h = Documento(), Historico()
h.executar(ColarTexto(doc, "ola", 0))
h.desfazer()