implementing examples for design patterns

Author: AryanHamedani

adapter/adapter_via_inheritance.py

@@ -0,0 +1,54 @@
+class Target:
+    """
+    The Target defines the domain-specific interface used by the client code.
+    """
+
+    def request(self) -> str:
+        return "Target: The default target's behavior."
+
+
+class Adaptee:
+    """
+    The Adaptee contains some useful behavior, but its interface is incompatible
+    with the existing client code. The Adaptee needs some adaptation before the
+    client code can use it.
+    """
+
+    def specific_request(self) -> str:
+        return ".eetpadA eht fo roivaheb laicepS"
+
+
+class Adapter(Target, Adaptee):
+    """
+    The Adapter makes the Adaptee's interface compatible with the Target's
+    interface via multiple inheritance.
+    """
+
+    def request(self) -> str:
+        return f"Adapter: (TRANSLATED) {self.specific_request()[::-1]}"
+
+
+def client_code(target: "Target") -> None:
+    """
+    The client code supports all classes that follow the Target interface.
+    """
+
+    print(target.request(), end="")
+
+
+if __name__ == "__main__":
+    print("Client: I can work just fine with the Target objects:")
+    target = Target()
+    client_code(target)
+    print("\n")
+
+    adaptee = Adaptee()
+    print(
+        "Client: The Adaptee class has a weird interface. "
+        "See, I don't understand it:"
+    )
+    print(f"Adaptee: {adaptee.specific_request()}", end="\n\n")
+
+    print("Client: But I can work with it via the Adapter:")
+    adapter = Adapter()
+    client_code(adapter)

adapter/adapter_via_object_composition.py

@@ -0,0 +1,57 @@
+class Target:
+    """
+    The Target defines the domain-specific interface used by the client code.
+    """
+
+    def request(self) -> str:
+        return "Target: The default target's behavior."
+
+
+class Adaptee:
+    """
+    The Adaptee contains some useful behavior, but its interface is incompatible
+    with the existing client code. The Adaptee needs some adaptation before the
+    client code can use it.
+    """
+
+    def specific_request(self) -> str:
+        return ".eetpadA eht fo roivaheb laicepS"
+
+
+class Adapter(Target):
+    """
+    The Adapter makes the Adaptee's interface compatible with the Target's
+    interface via composition.
+    """
+
+    def __init__(self, adaptee: Adaptee) -> None:
+        self.adaptee = adaptee
+
+    def request(self) -> str:
+        return f"Adapter: (TRANSLATED) {self.adaptee.specific_request()[::-1]}"
+
+
+def client_code(target: Target) -> None:
+    """
+    The client code supports all classes that follow the Target interface.
+    """
+
+    print(target.request(), end="")
+
+
+if __name__ == "__main__":
+    print("Client: I can work just fine with the Target objects:")
+    target = Target()
+    client_code(target)
+    print("\n")
+
+    adaptee = Adaptee()
+    print(
+        "Client: The Adaptee class has a weird interface. "
+        "See, I don't understand it:"
+    )
+    print(f"Adaptee: {adaptee.specific_request()}", end="\n\n")
+
+    print("Client: But I can work with it via the Adapter:")
+    adapter = Adapter(adaptee)
+    client_code(adapter)

decorator/decorator.py

@@ -0,0 +1,100 @@
+class Component:
+    """
+    The base Component interface defines operations that can be altered by
+    decorators.
+    """
+
+    def operation(self) -> str:
+        pass
+
+
+class ConcreteComponent(Component):
+    """
+    Concrete Components provide default implementations of the operations. There
+    might be several variations of these classes.
+    """
+
+    def operation(self) -> str:
+        return "ConcreteComponent"
+
+
+class Decorator(Component):
+    """
+    The base Decorator class follows the same interface as the other components.
+    The primary purpose of this class is to define the wrapping interface for
+    all concrete decorators. The default implementation of the wrapping code
+    might include a field for storing a wrapped component and the means to
+    initialize it.
+    """
+
+    _component: Component = None
+
+    def __init__(self, component: Component) -> None:
+        self._component = component
+
+    @property
+    def component(self) -> Component:
+        """
+        The Decorator delegates all work to the wrapped component.
+        """
+
+        return self._component
+
+    def operation(self) -> str:
+        return self._component.operation()
+
+
+class ConcreteDecoratorA(Decorator):
+    """
+    Concrete Decorators call the wrapped object and alter its result in some
+    way.
+    """
+
+    def operation(self) -> str:
+        """
+        Decorators may call parent implementation of the operation, instead of
+        calling the wrapped object directly. This approach simplifies extension
+        of decorator classes.
+        """
+        return f"ConcreteDecoratorA({self.component.operation()})"
+
+
+class ConcreteDecoratorB(Decorator):
+    """
+    Decorators can execute their behavior either before or after the call to a
+    wrapped object.
+    """
+
+    def operation(self) -> str:
+        return f"ConcreteDecoratorB({self.component.operation()})"
+
+
+def client_code(component: Component) -> None:
+    """
+    The client code works with all objects using the Component interface. This
+    way it can stay independent of the concrete classes of components it works
+    with.
+    """
+
+    # ...
+
+    print(f"RESULT: {component.operation()}", end="")
+
+    # ...
+
+
+if __name__ == "__main__":
+    # This way the client code can support both simple components...
+    simple = ConcreteComponent()
+    print("Client: I've got a simple component:")
+    client_code(simple)
+    print("\n")
+
+    # ...as well as decorated ones.
+    #
+    # Note how decorators can wrap not only simple components but the other
+    # decorators as well.
+    decorator1 = ConcreteDecoratorA(simple)
+    decorator2 = ConcreteDecoratorB(decorator1)
+    print("Client: Now I've got a decorated component:")
+    client_code(decorator2)

facade/facade.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+
+class Facade:
+    """
+    The Facade class provides a simple interface to the complex logic of one or
+    several subsystems. The Facade delegates the client requests to the
+    appropriate objects within the subsystem. The Facade is also responsible for
+    managing their lifecycle. All of this shields the client from the undesired
+    complexity of the subsystem.
+    """
+
+    def __init__(self, subsystem1: Subsystem1, subsystem2: Subsystem2) -> None:
+        """
+        Depending on your application's needs, you can provide the Facade with
+        existing subsystem objects or force the Facade to create them on its
+        own.
+        """
+
+        self._subsystem1 = subsystem1 or Subsystem1()
+        self._subsystem2 = subsystem2 or Subsystem2()
+
+    def operation(self) -> str:
+        """
+        The Facade's methods are convenient shortcuts to the sophisticated
+        functionality of the subsystems. However, clients get only to a fraction
+        of a subsystem's capabilities.
+        """
+
+        results = []
+        results.append("Facade initializes subsystems:")
+        results.append(self._subsystem1.operation1())
+        results.append(self._subsystem2.operation1())
+        results.append("Facade orders subsystems to perform the action:")
+        results.append(self._subsystem1.operation_n())
+        results.append(self._subsystem2.operation_z())
+        return "\n".join(results)
+
+
+class Subsystem1:
+    """
+    The Subsystem can accept requests either from the facade or client directly.
+    In any case, to the Subsystem, the Facade is yet another client, and it's
+    not a part of the Subsystem.
+    """
+
+    def operation1(self) -> str:
+        return "Subsystem1: Ready!"
+
+    # ...
+
+    def operation_n(self) -> str:
+        return "Subsystem1: Go!"
+
+
+class Subsystem2:
+    """
+    Some facades can work with multiple subsystems at the same time.
+    """
+
+    def operation1(self) -> str:
+        return "Subsystem2: Get ready!"
+
+    # ...
+
+    def operation_z(self) -> str:
+        return "Subsystem2: Fire!"
+
+
+def client_code(facade: Facade) -> None:
+    """
+    The client code works with complex subsystems through a simple interface
+    provided by the Facade. When a facade manages the lifecycle of the
+    subsystem, the client might not even know about the existence of the
+    subsystem. This approach lets you keep the complexity under control.
+    """
+
+    print(facade.operation(), end="")
+
+
+if __name__ == "__main__":
+    # The client code may have some of the subsystem's objects already created.
+    # In this case, it might be worthwhile to initialize the Facade with these
+    # objects instead of letting the Facade create new instances.
+    subsystem1 = Subsystem1()
+    subsystem2 = Subsystem2()
+    facade = Facade(subsystem1, subsystem2)
+    client_code(facade)