Python Design Patterns: Command

from __future__ import annotations
from abc import ABC, abstractmethod
class Command(ABC):
    """
    The Command interface declares a method for executing a command.
    """
    @abstractmethod
    def execute(self) -> None:
        pass
class SimpleCommand(Command):
    """
    Some commands can implement simple operations on their own.
    """
    def __init__(self, payload: str) -> None:
        self._payload = payload
    def execute(self) -> None:
        print(f"SimpleCommand: See, I can do simple things like printing"
              f"({self._payload})")
class ComplexCommand(Command):
    """
    Tuy nhiên, một số Command có thể ủy thác các hoạt động phức tạp hơn 
    cho các đối tượng khác, được gọi là "receivers."
    """
    def __init__(self, receiver: Receiver, a: str, b: str) -> None:
        """
        Các Command phức tạp có thể chấp nhận một hoặc một số đối tượng receiver
        cùng với bất kỳ dữ liệu ngữ cảnh nào thông qua phương thức khởi tạo.
        """
        self._receiver = receiver
        self._a = a
        self._b = b
    def execute(self) -> None:
        """
        Các Command có thể ủy quyền cho bất kỳ phương thức nào của receiver.
        """
        print("ComplexCommand: Complex stuff should be done by a receiver object", end="")
        self._receiver.do_something(self._a)
        self._receiver.do_something_else(self._b)
class Receiver:
    """
    Các lớp Receiver chứa một số logic nghiệp vụ quan trọng. Chúng biết cách thực 
    hiện tất cả các loại hoạt động, liên quan đến việc thực hiện một yêu cầu.
    Trên thực tế, bất kỳ lớp nào cũng có thể đóng vai trò là Receiver.
    """
    def do_something(self, a: str) -> None:
        print(f"\nReceiver: Working on ({a}.)", end="")
    def do_something_else(self, b: str) -> None:
        print(f"\nReceiver: Also working on ({b}.)", end="")
class Invoker:
    """
    Invoker liên kết với một hoặc một số Command. Nó gửi một yêu cầu đến Command.
    """
    _on_start = None
    _on_finish = None
    """
    Initialize commands.
    """
    def set_on_start(self, command: Command):
        self._on_start = command
    def set_on_finish(self, command: Command):
        self._on_finish = command
    def do_something_important(self) -> None:
        """
        Invoker không phụ thuộc vào các lớp command. Invoker chuyển một yêu 
        cầu đến receiver gián tiếp, bằng cách thực hiện một command.
        """
        print("Invoker: Does anybody want something done before I begin?")
        if isinstance(self._on_start, Command):
            self._on_start.execute()
        print("Invoker: ...doing something really important...")
        print("Invoker: Does anybody want something done after I finish?")
        if isinstance(self._on_finish, Command):
            self._on_finish.execute()
if __name__ == "__main__":
    """
    Mã client có thể tham số hóa một invoker bằng bất kỳ lệnh nào.
    """
    invoker = Invoker()
    invoker.set_on_start(SimpleCommand("Say Hi!"))
    receiver = Receiver()
    invoker.set_on_finish(ComplexCommand(
        receiver, "Send email", "Save report"))
    invoker.do_something_important()

Invoker: Does anybody want something done before I begin?
SimpleCommand: See, I can do simple things like printing (Say Hi!)
Invoker: ...doing something really important...
Invoker: Does anybody want something done after I finish?
ComplexCommand: Complex stuff should be done by a receiver object.
Receiver: Working on (Send email)
Receiver: Also working on (Save report)