add code example

behavioral/command/command.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class Command(ABC):
+    """
+    The Command interface declares a method for executing a command.
+    """
+
+    @abstractmethod
+    def execute(self) -> None:
+        pass

behavioral/command/commands.py

@@ -0,0 +1,41 @@
+from behavioral.command.command import Command
+from behavioral.command.receiver import Receiver
+
+
+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 ({self._payload})")
+
+
+class ComplexCommand(Command):
+    """
+    However, some commands can delegate more complex operations to other
+    objects, called "receivers."
+    """
+
+    def __init__(self, receiver: Receiver, a: str, b: str) -> None:
+        """
+        Complex commands can accept one or several receiver objects along with
+        any context data via the constructor.
+        """
+
+        self._receiver = receiver
+        self._a = a
+        self._b = b
+
+    def execute(self) -> None:
+        """
+        Commands can delegate to any methods of 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)

behavioral/command/invoker.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from behavioral.command.command import Command
+
+
+class Invoker:
+    """
+    The Invoker is associated with one or several commands. It sends a request
+    to the command.
+    """
+
+    _on_start: Optional[Command] = None
+    _on_finish: Optional[Command] = None
+
+    """Initialize commands."""
+
+    def set_on_start(self, command: Command) -> None:
+        self._on_start = command
+
+    def set_on_finish(self, command: Command) -> None:
+        self._on_finish = command
+
+    def do_something_important(self) -> None:
+        """
+        The Invoker does not depend on concrete command or receiver classes. The
+        Invoker passes a request to a receiver indirectly, by executing a
+        command.
+        """
+
+        print("Invoker: Does anybody want something done before I begin?")
+        if self._on_start:
+            self._on_start.execute()
+
+        print("Invoker: ...doing something really important...")
+
+        print("Invoker: Does anybody want something done after I finish?")
+        if self._on_finish:
+            self._on_finish.execute()

behavioral/command/main.py

@@ -0,0 +1,16 @@
+"""
+The client code can parameterize an invoker with any commands.
+"""
+from behavioral.command.commands import SimpleCommand, ComplexCommand
+from behavioral.command.invoker import Invoker
+from behavioral.command.receiver import Receiver
+
+if __name__ == '__main__':
+    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()

behavioral/command/receiver.py

@@ -0,0 +1,12 @@
+class Receiver:
+    """
+    The Receiver classes contain some important business logic. They know how to
+    perform all kinds of operations, associated with carrying out a request. In
+    fact, any class may serve as a 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="")