PL-DPL

Peach's Lightweight Design Pattern Library

Low code, low dependency, simple implementation of commonly used design patterns.

Quick Start

Install library

pip install pl-dpl

Factory

Lazy Loading Self-Registering Factory Design Pattern.

Create a subclass of BaseFactory, specify the directory where concrete implementations exist, define abstract functions.

**NOTE: Only include one implementation per file in the plugin directory, registration is done by module name, not class name. This makes it more readable for developers so when they look at the config and see "s3" they can immediately see the file "s3.py" and know where the implementation is.

Usage

Create packages for implementations:

src/
|-- storage/
|  |-- s3.py
|-- storage_factory.py
|-- main.py

./main.py

from storage_factory import StorageFactory

data = b'123'

StorageFactory("s3").save(data)

./storage_factory

from patterns import BaseFactory

# Create Factory
class StorageFactory(BaseFactory):
    plugin_dir = "storage"
    _registry = {}

    # Define Abstract Functions
    def save(self, data: bytes):
        raise NotImplementedError

./storage/s3.py

from storage_factory import StorageFactory

# Create implementation
class S3(StorageFactory):
    def save(self, data: bytes):
        ...

Chain

Lazy Loading Self-Registering Chain of Responsibility.

Create a subclass of BaseHandler (a BaseFactory), specify the directory where concrete handlers exist, implement handle() on each link.

**NOTE: Only include one handler per file in the plugin directory, registration is done by module name, not class name.

Usage

Create packages for handlers:

src/
|-- middleware/
|  |-- handlers/
|  |  |-- ping_pong.py
|-- middleware.py
|-- main.py

./main.py

from patterns import ChainManager

from middleware import MiddlewareHandler

config = [
    {"name": "ping_pong", "config": {"prefix": "ping"}},
    {"name": "ping_pong", "config": {"prefix": "pong"}},
]

chain = ChainManager(MiddlewareHandler, config)
result = chain.execute("ping")

./middleware.py

from patterns import BaseHandler

# Logic group for the chain
class MiddlewareHandler(BaseHandler):
    plugin_dir = ".handlers"
    _registry = {}

./middleware/handlers/ping_pong.py

from middleware import MiddlewareHandler

# A chain link. handle() returns (should_continue, result):
# True passes to the next link, False breaks the chain.
class PingPong(MiddlewareHandler):
    def handle(self, request):
        should_continue = request.lower().startswith(self._config["prefix"])

        if not should_continue:
            return not should_continue, request

        return should_continue, f"I accept your {self._config['prefix']}"

Entity

TODO:

Command

TODO: