Working on system automation since scripts move. updated files and generated docs.

Author: taggedzi

chunks/behavioral_chain_of_responsibility.md

@@ -0,0 +1,83 @@
+---
+file: behavioral/chain_of_responsibility.py
+chunk: behavioral_chain_of_responsibility.md
+---
+
+```python
+"""
+Behavioral Pattern: Chain of Responsibility
+
+Lets you pass requests along a chain of handlers, where each handler decides
+whether to process the request or pass it along.
+Promotes loose coupling between sender and receiver.
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Optional
+
+class Handler(ABC):
+    """Base Handler class with chaining support."""
+
+    _next_handler: Optional[Handler] = None
+
+    def set_next(self, handler: Handler) -> Handler:
+        self._next_handler = handler
+        return handler
+
+    @abstractmethod
+    def handle(self, request: str) -> Optional[str]:
+        pass
+
+class MonkeyHandler(Handler):
+    def handle(self, request: str) -> Optional[str]:
+        if request == "Banana":
+            return "Monkey: I'll eat the Banana."
+        elif self._next_handler:
+            return self._next_handler.handle(request)
+        return None
+
+class SquirrelHandler(Handler):
+    def handle(self, request: str) -> Optional[str]:
+        if request == "Nut":
+            return "Squirrel: I'll eat the Nut."
+        elif self._next_handler:
+            return self._next_handler.handle(request)
+        return None
+
+class DogHandler(Handler):
+    def handle(self, request: str) -> Optional[str]:
+        if request == "Meat":
+            return "Dog: I'll eat the Meat."
+        elif self._next_handler:
+            return self._next_handler.handle(request)
+        return None
+
+# Example usage
+if __name__ == "__main__":
+    monkey = MonkeyHandler()
+    squirrel = SquirrelHandler()
+    dog = DogHandler()
+
+    monkey.set_next(squirrel).set_next(dog)
+
+    for food in ["Nut", "Banana", "Meat", "Apple"]:
+        print(f"Client: Who wants a {food}?")
+        result = monkey.handle(food)
+        if result:
+            print(result)
+        else:
+            print(f"No one wants the {food}.")
+```
+
+## Summary
+Implementation of the Chain of Responsibility pattern in Python.
+
+## Docstrings
+- Base Handler class with chaining support.
+- Sets the next handler in the chain and returns the next handler.
+- Abstract method to handle requests. Must be implemented by subclasses.
+- Handler for monkeys that can eat bananas.
+- Handler for squirrels that can eat nuts.
+- Handler for dogs that can eat meat.
+

chunks/behavioral_command.md

@@ -0,0 +1,77 @@
+---
+file: behavioral/command.py
+chunk: behavioral_command.md
+---
+
+```python
+"""
+Behavioral Pattern: Command
+
+Encapsulates a request as an object, thereby allowing for parameterization of clients with queues,
+requests, and operations, and supports undoable actions.
+"""
+
+from abc import ABC, abstractmethod
+
+# Command interface
+class Command(ABC):
+    @abstractmethod
+    def execute(self) -> None:
+        pass
+
+# Receiver
+class Light:
+    def turn_on(self) -> None:
+        print("Light is ON")
+
+    def turn_off(self) -> None:
+        print("Light is OFF")
+
+# Concrete commands
+class TurnOnCommand(Command):
+    def __init__(self, light: Light) -> None:
+        self._light = light
+
+    def execute(self) -> None:
+        self._light.turn_on()
+
+class TurnOffCommand(Command):
+    def __init__(self, light: Light) -> None:
+        self._light = light
+
+    def execute(self) -> None:
+        self._light.turn_off()
+
+# Invoker
+class RemoteControl:
+    def __init__(self) -> None:
+        self._commands: list[Command] = []
+
+    def submit(self, command: Command) -> None:
+        self._commands.append(command)
+        command.execute()
+
+# Example usage
+if __name__ == "__main__":
+    light = Light()
+    on_command = TurnOnCommand(light)
+    off_command = TurnOffCommand(light)
+
+    remote = RemoteControl()
+    remote.submit(on_command)
+    remote.submit(off_command)
+
+```
+
+## Summary
+Implementation of the Command Design Pattern in Python
+
+## Docstrings
+- Encapsulates a request as an object, allowing for parameterization of clients with queues, requests, and operations, and supports undoable actions.
+- Abstract base class representing a command. Must implement the execute method.
+- Concrete command that turns on a light.
+- Concrete command that turns off a light.
+- Abstract base class representing a receiver. Provides methods for turning on and off a light.
+- Class representing a remote control that can submit commands and execute them.
+- Example usage of the Command pattern to control a light.
+

chunks/behavioral_interpreter.md

@@ -0,0 +1,72 @@
+---
+file: behavioral/interpreter.py
+chunk: behavioral_interpreter.md
+---
+
+```python
+"""
+Behavioral Pattern: Interpreter
+
+Defines a representation for a grammar and an interpreter that uses the representation
+to interpret sentences in the language. Useful for simple language parsing.
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Dict
+
+# Context provides input for interpretation
+class Context:
+    def __init__(self, variables: Dict[str, int]) -> None:
+        self.variables = variables
+
+# Abstract Expression
+class Expression(ABC):
+    @abstractmethod
+    def interpret(self, context: Context) -> int:
+        pass
+
+# Terminal Expression
+class Variable(Expression):
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def interpret(self, context: Context) -> int:
+        return context.variables.get(self.name, 0)
+
+# Non-terminal Expressions
+class Add(Expression):
+    def __init__(self, left: Expression, right: Expression) -> None:
+        self.left = left
+        self.right = right
+
+    def interpret(self, context: Context) -> int:
+        return self.left.interpret(context) + self.right.interpret(context)
+
+class Subtract(Expression):
+    def __init__(self, left: Expression, right: Expression) -> None:
+        self.left = left
+        self.right = right
+
+    def interpret(self, context: Context) -> int:
+        return self.left.interpret(context) - self.right.interpret(context)
+
+# Example usage
+if __name__ == "__main__":
+    context = Context({"x": 10, "y": 5})
+    expr = Add(Variable("x"), Subtract(Variable("y"), Variable("z")))  # x + (y - z)
+    print("Result:", expr.interpret(context))
+
+```
+
+## Summary
+This code defines a simple interpreter for a basic arithmetic language using the Interpreter pattern.
+
+## Docstrings
+- Defines a representation for a grammar and an interpreter that uses the representation to interpret sentences in the language. Useful for simple language parsing.
+- Context provides input for interpretation
+- Abstract Expression
+- Terminal Expression
+- Non-terminal Expressions
+- Example usage
+

chunks/behavioral_memento.md

@@ -0,0 +1,83 @@
+---
+file: behavioral/memento.py
+chunk: behavioral_memento.md
+---
+
+```python
+"""
+Behavioral Pattern: Memento
+
+Captures and externalizes an object's internal state so that it can be restored later,
+without violating encapsulation. Useful for undo mechanisms.
+"""
+
+from __future__ import annotations
+from typing import List
+
+# Memento
+class Memento:
+    def __init__(self, state: str) -> None:
+        self._state = state
+
+    def get_state(self) -> str:
+        return self._state
+
+# Originator
+class TextEditor:
+    def __init__(self) -> None:
+        self._state = ""
+
+    def write(self, text: str) -> None:
+        self._state += text
+
+    def save(self) -> Memento:
+        return Memento(self._state)
+
+    def restore(self, memento: Memento) -> None:
+        self._state = memento.get_state()
+
+    def get_content(self) -> str:
+        return self._state
+
+# Caretaker
+class History:
+    def __init__(self) -> None:
+        self._history: List[Memento] = []
+
+    def backup(self, memento: Memento) -> None:
+        self._history.append(memento)
+
+    def undo(self) -> Memento:
+        return self._history.pop()
+
+# Example usage
+if __name__ == "__main__":
+    editor = TextEditor()
+    history = History()
+
+    editor.write("Hello, ")
+    history.backup(editor.save())
+
+    editor.write("world!")
+    print("Current content:", editor.get_content())
+
+    editor.restore(history.undo())
+    print("After undo:", editor.get_content())
+```
+
+## Summary
+Implements the Memento design pattern for a text editor, allowing state restoration and undo functionality.
+
+## Docstrings
+- Captures and externalizes an object's internal state so that it can be restored later, without violating encapsulation.
+- Initializes a Memento with a given state.
+- Returns the state stored in the Memento.
+- Initializes a TextEditor with an empty state.
+- Writes text to the editor, updating its internal state.
+- Saves the current state of the TextEditor as a Memento.
+- Restores the TextEditor's state from a given Memento.
+- Returns the current content of the TextEditor.
+- Initializes a History to keep track of Mementos.
+- Adds a Memento to the history list.
+- Removes and returns the last Memento from the history list.
+