gridflow-python-mediator 0.1.0__tar.gz

gridflow_python_mediator-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: gridflow-python-mediator
+Version: 0.1.0
+Summary: Generic mediator pattern with pipeline behaviors
+Author-email: GridFlow Team <vialogue@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/firstunicorn/python-web-toolkit
+Project-URL: Repository, https://github.com/firstunicorn/python-web-toolkit
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: logging
+Requires-Dist: structlog>=23.0.0; extra == "logging"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+
+# gridflow-python-mediator
+
+Generic mediator pattern implementation with zero dependencies and pipeline behavior support.
+
+**Extracted from:** GridFlow `backend/src/apps/token_generator/application/common/mediator/`
+
+## Installation
+
+```bash
+# Core (zero dependencies)
+pip install gridflow-python-mediator
+
+# With logging support
+pip install gridflow-python-mediator[logging]
+```
+
+## Features
+
+- **Zero Dependencies**: Pure Python implementation
+- **Pipeline Behaviors**: Logging, timing, validation
+- **Type-Safe**: Full generic type support
+- **Async/Sync**: Supports both async and sync handlers
+
+## Usage
+
+### Basic Mediator
+
+```python
+from gridflow_python_mediator import Mediator
+
+# Define request and handler
+class GetUserRequest:
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+
+class GetUserHandler:
+    async def handle(self, request: GetUserRequest):
+        # Fetch user logic
+        return {"id": request.user_id, "name": "John"}
+
+# Setup mediator
+mediator = Mediator()
+mediator.register_handler(GetUserRequest, GetUserHandler())
+
+# Send request
+request = GetUserRequest(user_id=1)
+result = await mediator.send(request)
+```
+
+### With CQRS
+
+```python
+from python_cqrs_core import BaseCommand, ICommandHandler
+from gridflow_python_mediator import Mediator
+
+class CreateUserCommand(BaseCommand):
+    name: str
+    email: str
+
+class CreateUserHandler(ICommandHandler[CreateUserCommand, int]):
+    async def handle(self, command: CreateUserCommand) -> int:
+        # Create user
+        return user_id
+
+mediator = Mediator()
+mediator.register_handler(CreateUserCommand, CreateUserHandler())
+
+cmd = CreateUserCommand(name="John", email="john@example.com")
+user_id = await mediator.send(cmd)
+```
+
+### Pipeline Behaviors
+
+```python
+from gridflow_python_mediator import (
+    Mediator,
+    LoggingBehavior,
+    TimingBehavior,
+    ValidationBehavior
+)
+
+mediator = Mediator()
+
+# Add behaviors (executed in order)
+mediator.add_pipeline_behavior(LoggingBehavior().handle)
+mediator.add_pipeline_behavior(TimingBehavior().handle)
+mediator.add_pipeline_behavior(ValidationBehavior().handle)
+
+# Behaviors run before handler
+result = await mediator.send(request)
+```
+
+### Custom Behavior
+
+```python
+async def auth_behavior(request, handler):
+    """Check authentication before handler."""
+    if not request.user_id:
+        raise ValueError("Unauthorized")
+    return None  # Continue to handler
+
+mediator.add_pipeline_behavior(auth_behavior)
+```
+
+## API Reference
+
+### `Mediator`
+
+Generic request/response dispatcher.
+
+**Methods:**
+
+#### `register_handler(request_type, handler)`
+
+Register handler for request type.
+
+**Parameters:**
+- `request_type` (Type): Request class
+- `handler` (Any): Handler instance with `handle()` method
+
+#### `async send(request) -> TResult`
+
+Dispatch request to handler.
+
+**Parameters:**
+- `request` (TRequest): Request to send
+
+**Returns:**
+- Result from handler
+
+#### `add_pipeline_behavior(behavior)`
+
+Add pipeline behavior.
+
+**Parameters:**
+- `behavior` (Callable): Async function(request, handler) -> Optional[result]
+
+### Built-in Behaviors
+
+#### `LoggingBehavior`
+
+Logs request type before/after handler.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `TimingBehavior`
+
+Measures and logs execution duration.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `ValidationBehavior`
+
+Validates Pydantic models before handler.
+
+## Design Patterns
+
+### Mediator Pattern
+
+Decouples senders from receivers:
+- Single point of dispatch
+- Handler registration
+- Pipeline behaviors
+
+### Pipeline Pattern
+
+Behaviors execute in order:
+1. Logging
+2. Timing
+3. Validation
+4. Handler
+
+## Dependencies
+
+- **Core**: None (zero dependencies!)
+- **Optional**: `structlog>=23.0.0` (for logging behaviors)
+
+## License
+
+MIT

gridflow_python_mediator-0.1.0/README.md

@@ -0,0 +1,180 @@
+# gridflow-python-mediator
+
+Generic mediator pattern implementation with zero dependencies and pipeline behavior support.
+
+**Extracted from:** GridFlow `backend/src/apps/token_generator/application/common/mediator/`
+
+## Installation
+
+```bash
+# Core (zero dependencies)
+pip install gridflow-python-mediator
+
+# With logging support
+pip install gridflow-python-mediator[logging]
+```
+
+## Features
+
+- **Zero Dependencies**: Pure Python implementation
+- **Pipeline Behaviors**: Logging, timing, validation
+- **Type-Safe**: Full generic type support
+- **Async/Sync**: Supports both async and sync handlers
+
+## Usage
+
+### Basic Mediator
+
+```python
+from gridflow_python_mediator import Mediator
+
+# Define request and handler
+class GetUserRequest:
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+
+class GetUserHandler:
+    async def handle(self, request: GetUserRequest):
+        # Fetch user logic
+        return {"id": request.user_id, "name": "John"}
+
+# Setup mediator
+mediator = Mediator()
+mediator.register_handler(GetUserRequest, GetUserHandler())
+
+# Send request
+request = GetUserRequest(user_id=1)
+result = await mediator.send(request)
+```
+
+### With CQRS
+
+```python
+from python_cqrs_core import BaseCommand, ICommandHandler
+from gridflow_python_mediator import Mediator
+
+class CreateUserCommand(BaseCommand):
+    name: str
+    email: str
+
+class CreateUserHandler(ICommandHandler[CreateUserCommand, int]):
+    async def handle(self, command: CreateUserCommand) -> int:
+        # Create user
+        return user_id
+
+mediator = Mediator()
+mediator.register_handler(CreateUserCommand, CreateUserHandler())
+
+cmd = CreateUserCommand(name="John", email="john@example.com")
+user_id = await mediator.send(cmd)
+```
+
+### Pipeline Behaviors
+
+```python
+from gridflow_python_mediator import (
+    Mediator,
+    LoggingBehavior,
+    TimingBehavior,
+    ValidationBehavior
+)
+
+mediator = Mediator()
+
+# Add behaviors (executed in order)
+mediator.add_pipeline_behavior(LoggingBehavior().handle)
+mediator.add_pipeline_behavior(TimingBehavior().handle)
+mediator.add_pipeline_behavior(ValidationBehavior().handle)
+
+# Behaviors run before handler
+result = await mediator.send(request)
+```
+
+### Custom Behavior
+
+```python
+async def auth_behavior(request, handler):
+    """Check authentication before handler."""
+    if not request.user_id:
+        raise ValueError("Unauthorized")
+    return None  # Continue to handler
+
+mediator.add_pipeline_behavior(auth_behavior)
+```
+
+## API Reference
+
+### `Mediator`
+
+Generic request/response dispatcher.
+
+**Methods:**
+
+#### `register_handler(request_type, handler)`
+
+Register handler for request type.
+
+**Parameters:**
+- `request_type` (Type): Request class
+- `handler` (Any): Handler instance with `handle()` method
+
+#### `async send(request) -> TResult`
+
+Dispatch request to handler.
+
+**Parameters:**
+- `request` (TRequest): Request to send
+
+**Returns:**
+- Result from handler
+
+#### `add_pipeline_behavior(behavior)`
+
+Add pipeline behavior.
+
+**Parameters:**
+- `behavior` (Callable): Async function(request, handler) -> Optional[result]
+
+### Built-in Behaviors
+
+#### `LoggingBehavior`
+
+Logs request type before/after handler.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `TimingBehavior`
+
+Measures and logs execution duration.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `ValidationBehavior`
+
+Validates Pydantic models before handler.
+
+## Design Patterns
+
+### Mediator Pattern
+
+Decouples senders from receivers:
+- Single point of dispatch
+- Handler registration
+- Pipeline behaviors
+
+### Pipeline Pattern
+
+Behaviors execute in order:
+1. Logging
+2. Timing
+3. Validation
+4. Handler
+
+## Dependencies
+
+- **Core**: None (zero dependencies!)
+- **Optional**: `structlog>=23.0.0` (for logging behaviors)
+
+## License
+
+MIT

gridflow_python_mediator-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "gridflow-python-mediator"
+version = "0.1.0"
+description = "Generic mediator pattern with pipeline behaviors"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "GridFlow Team", email = "vialogue@proton.me"}
+]
+
+dependencies = []  # Zero dependencies - pure Python!
+
+[project.urls]
+Homepage = "https://github.com/firstunicorn/python-web-toolkit"
+Repository = "https://github.com/firstunicorn/python-web-toolkit"
+
+[project.optional-dependencies]
+logging = ["structlog>=23.0.0"]  # For logging behaviors
+dev = [
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.0",
+]
+
+[build-system]
+requires = ["setuptools>=68.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.0.2,<10.0.0)",
+    "pytest-asyncio (>=0.21.0)",
+    "hypothesis (>=6.151.5,<7.0.0)"
+]

gridflow_python_mediator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/__init__.py

@@ -0,0 +1,19 @@
+"""Python Mediator - Generic mediator pattern implementation."""
+
+from gridflow_python_mediator.mediator import Mediator
+from gridflow_python_mediator.behaviors import (
+    PipelineBehavior,
+    LoggingBehavior,
+    TimingBehavior,
+    ValidationBehavior
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Mediator",
+    "PipelineBehavior",
+    "LoggingBehavior",
+    "TimingBehavior",
+    "ValidationBehavior",
+]

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/behaviors/__init__.py

@@ -0,0 +1,17 @@
+"""Pipeline behaviors for cross-cutting concerns."""
+
+from gridflow_python_mediator.behaviors.protocol import PipelineBehavior
+from gridflow_python_mediator.behaviors.observability import (
+    LoggingBehavior,
+    TimingBehavior,
+)
+from gridflow_python_mediator.behaviors.validation_behavior import (
+    ValidationBehavior,
+)
+
+__all__ = [
+    "PipelineBehavior",
+    "LoggingBehavior",
+    "TimingBehavior",
+    "ValidationBehavior",
+]

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/behaviors/observability.py

@@ -0,0 +1,85 @@
+"""Logging and timing pipeline behaviors."""
+
+from typing import Any, Callable, Optional
+import time
+
+try:
+    import structlog
+    logger = structlog.get_logger()
+except ImportError:
+    import logging
+    logger = logging.getLogger(__name__)
+
+
+class LoggingBehavior:
+    """Pipeline behavior for logging requests.
+
+    Logs request type before and after handler execution.
+
+    Example:
+        >>> mediator.add_pipeline_behavior(
+        ...     LoggingBehavior().handle
+        ... )
+    """
+
+    async def handle(
+        self,
+        request: Any,
+        next: Callable
+    ) -> Optional[Any]:
+        """Log request handling.
+
+        Args:
+            request: Request being handled
+            next: Next handler
+
+        Returns:
+            None (continues to handler)
+        """
+        request_type = type(request).__name__
+        logger.info("Handling request", request_type=request_type)
+
+        result = await next(request)
+
+        logger.info("Request completed", request_type=request_type)
+        return result
+
+
+class TimingBehavior:
+    """Pipeline behavior for timing request execution.
+
+    Measures and logs execution duration.
+
+    Example:
+        >>> mediator.add_pipeline_behavior(
+        ...     TimingBehavior().handle
+        ... )
+    """
+
+    async def handle(
+        self,
+        request: Any,
+        next: Callable
+    ) -> Optional[Any]:
+        """Time request handling.
+
+        Args:
+            request: Request being handled
+            next: Next handler
+
+        Returns:
+            Handler result
+        """
+        start = time.time()
+        request_type = type(request).__name__
+
+        result = await next(request)
+
+        duration_ms = int((time.time() - start) * 1000)
+        logger.info(
+            "Request timing",
+            request_type=request_type,
+            duration_ms=duration_ms
+        )
+
+        return result

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/behaviors/protocol.py

@@ -0,0 +1,36 @@
+"""PipelineBehavior protocol definition."""
+
+from typing import Any, Callable, Protocol, Optional
+
+
+class PipelineBehavior(Protocol):
+    """Protocol for pipeline behaviors.
+
+    Behaviors execute before handler and can:
+    - Log/monitor requests
+    - Validate requests
+    - Transform requests
+    - Short-circuit execution
+
+    Example:
+        >>> class CustomBehavior:
+        ...     async def handle(self, request, next):
+        ...         # Custom logic
+        ...         return await next(request)
+    """
+
+    async def handle(
+        self,
+        request: Any,
+        next: Callable
+    ) -> Optional[Any]:
+        """Handle request in pipeline.
+
+        Args:
+            request: Request to handle
+            next: Next handler in pipeline
+
+        Returns:
+            Result (or None to continue pipeline)
+        """
+        ...

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/behaviors/validation_behavior.py

@@ -0,0 +1,38 @@
+"""Validation pipeline behavior for Pydantic models."""
+
+from typing import Any, Callable, Optional
+
+
+class ValidationBehavior:
+    """Pipeline behavior for request validation.
+
+    Validates Pydantic models before handler execution.
+
+    Example:
+        >>> mediator.add_pipeline_behavior(
+        ...     ValidationBehavior().handle
+        ... )
+    """
+
+    async def handle(
+        self,
+        request: Any,
+        next: Callable
+    ) -> Optional[Any]:
+        """Validate request.
+
+        Args:
+            request: Request to validate
+            next: Next handler
+
+        Returns:
+            Handler result
+
+        Raises:
+            ValidationError: If validation fails
+        """
+        # Validate if Pydantic model
+        if hasattr(request, 'model_validate'):
+            request.model_validate(request)
+
+        return await next(request)

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator/mediator.py

@@ -0,0 +1,110 @@
+"""Core mediator for request/response dispatch.
+
+Extracted from GridFlow backend/src/apps/token_generator/application/common/mediator/mediator.py
+"""
+
+from typing import TypeVar, Type, Dict, Any, Callable, List
+import inspect
+
+TRequest = TypeVar('TRequest')
+TResult = TypeVar('TResult')
+
+
+class Mediator:
+    """Generic request/response dispatcher (Mediator pattern).
+    
+    Decouples senders from handlers, allowing for:
+    - Pipeline behaviors (logging, timing, validation)
+    - Dynamic handler registration
+    - Type-safe dispatch
+    
+    Example:
+        >>> mediator = Mediator()
+        >>> mediator.register_handler(MyRequest, MyHandler())
+        >>> result = await mediator.send(MyRequest(...))
+    """
+    
+    def __init__(self):
+        """Initialize mediator with empty handler registry."""
+        self._handlers: Dict[Type, Any] = {}
+        self._behaviors: List[Callable] = []
+    
+    def register_handler(
+        self,
+        request_type: Type[TRequest],
+        handler: Any
+    ) -> None:
+        """Register handler for request type.
+        
+        Args:
+            request_type: Request/Command/Query type
+            handler: Handler instance with handle() method
+        
+        Raises:
+            ValueError: If handler already registered for type
+        
+        Example:
+            >>> mediator.register_handler(CreateUserCommand, CreateUserHandler())
+        """
+        if request_type in self._handlers:
+            raise ValueError(
+                f"Handler already registered for {request_type.__name__}"
+            )
+        self._handlers[request_type] = handler
+    
+    async def send(self, request: TRequest) -> TResult:
+        """Dispatch request to its registered handler.
+        
+        Executes pipeline behaviors before calling handler.
+        
+        Args:
+            request: Request/Command/Query to send
+        
+        Returns:
+            Result from handler
+        
+        Raises:
+            ValueError: If no handler registered for request type
+        
+        Example:
+            >>> cmd = CreateUserCommand(name="John")
+            >>> user_id = await mediator.send(cmd)
+        """
+        request_type = type(request)
+        handler = self._handlers.get(request_type)
+        
+        if not handler:
+            raise ValueError(
+                f"No handler registered for {request_type.__name__}"
+            )
+        
+        # Execute pipeline behaviors
+        for behavior in self._behaviors:
+            # Behaviors can modify request or short-circuit
+            result = await behavior(request, handler)
+            if result is not None:
+                return result
+        
+        # Execute handler
+        if inspect.iscoroutinefunction(handler.handle):
+            return await handler.handle(request)
+        else:
+            return handler.handle(request)
+    
+    def add_pipeline_behavior(self, behavior: Callable) -> None:
+        """Add pipeline behavior for cross-cutting concerns.
+        
+        Behaviors are executed in order before handler.
+        Can implement logging, timing, validation, etc.
+        
+        Args:
+            behavior: Async function(request, handler) -> Optional[result]
+        
+        Example:
+            >>> async def logging_behavior(request, handler):
+            ...     print(f"Handling {type(request).__name__}")
+            ...     return None  # Continue to handler
+            >>> 
+            >>> mediator.add_pipeline_behavior(logging_behavior)
+        """
+        self._behaviors.append(behavior)

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator.egg-info/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: gridflow-python-mediator
+Version: 0.1.0
+Summary: Generic mediator pattern with pipeline behaviors
+Author-email: GridFlow Team <vialogue@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/firstunicorn/python-web-toolkit
+Project-URL: Repository, https://github.com/firstunicorn/python-web-toolkit
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: logging
+Requires-Dist: structlog>=23.0.0; extra == "logging"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+
+# gridflow-python-mediator
+
+Generic mediator pattern implementation with zero dependencies and pipeline behavior support.
+
+**Extracted from:** GridFlow `backend/src/apps/token_generator/application/common/mediator/`
+
+## Installation
+
+```bash
+# Core (zero dependencies)
+pip install gridflow-python-mediator
+
+# With logging support
+pip install gridflow-python-mediator[logging]
+```
+
+## Features
+
+- **Zero Dependencies**: Pure Python implementation
+- **Pipeline Behaviors**: Logging, timing, validation
+- **Type-Safe**: Full generic type support
+- **Async/Sync**: Supports both async and sync handlers
+
+## Usage
+
+### Basic Mediator
+
+```python
+from gridflow_python_mediator import Mediator
+
+# Define request and handler
+class GetUserRequest:
+    def __init__(self, user_id: int):
+        self.user_id = user_id
+
+class GetUserHandler:
+    async def handle(self, request: GetUserRequest):
+        # Fetch user logic
+        return {"id": request.user_id, "name": "John"}
+
+# Setup mediator
+mediator = Mediator()
+mediator.register_handler(GetUserRequest, GetUserHandler())
+
+# Send request
+request = GetUserRequest(user_id=1)
+result = await mediator.send(request)
+```
+
+### With CQRS
+
+```python
+from python_cqrs_core import BaseCommand, ICommandHandler
+from gridflow_python_mediator import Mediator
+
+class CreateUserCommand(BaseCommand):
+    name: str
+    email: str
+
+class CreateUserHandler(ICommandHandler[CreateUserCommand, int]):
+    async def handle(self, command: CreateUserCommand) -> int:
+        # Create user
+        return user_id
+
+mediator = Mediator()
+mediator.register_handler(CreateUserCommand, CreateUserHandler())
+
+cmd = CreateUserCommand(name="John", email="john@example.com")
+user_id = await mediator.send(cmd)
+```
+
+### Pipeline Behaviors
+
+```python
+from gridflow_python_mediator import (
+    Mediator,
+    LoggingBehavior,
+    TimingBehavior,
+    ValidationBehavior
+)
+
+mediator = Mediator()
+
+# Add behaviors (executed in order)
+mediator.add_pipeline_behavior(LoggingBehavior().handle)
+mediator.add_pipeline_behavior(TimingBehavior().handle)
+mediator.add_pipeline_behavior(ValidationBehavior().handle)
+
+# Behaviors run before handler
+result = await mediator.send(request)
+```
+
+### Custom Behavior
+
+```python
+async def auth_behavior(request, handler):
+    """Check authentication before handler."""
+    if not request.user_id:
+        raise ValueError("Unauthorized")
+    return None  # Continue to handler
+
+mediator.add_pipeline_behavior(auth_behavior)
+```
+
+## API Reference
+
+### `Mediator`
+
+Generic request/response dispatcher.
+
+**Methods:**
+
+#### `register_handler(request_type, handler)`
+
+Register handler for request type.
+
+**Parameters:**
+- `request_type` (Type): Request class
+- `handler` (Any): Handler instance with `handle()` method
+
+#### `async send(request) -> TResult`
+
+Dispatch request to handler.
+
+**Parameters:**
+- `request` (TRequest): Request to send
+
+**Returns:**
+- Result from handler
+
+#### `add_pipeline_behavior(behavior)`
+
+Add pipeline behavior.
+
+**Parameters:**
+- `behavior` (Callable): Async function(request, handler) -> Optional[result]
+
+### Built-in Behaviors
+
+#### `LoggingBehavior`
+
+Logs request type before/after handler.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `TimingBehavior`
+
+Measures and logs execution duration.
+
+**Requires:** `structlog>=23.0.0`
+
+#### `ValidationBehavior`
+
+Validates Pydantic models before handler.
+
+## Design Patterns
+
+### Mediator Pattern
+
+Decouples senders from receivers:
+- Single point of dispatch
+- Handler registration
+- Pipeline behaviors
+
+### Pipeline Pattern
+
+Behaviors execute in order:
+1. Logging
+2. Timing
+3. Validation
+4. Handler
+
+## Dependencies
+
+- **Core**: None (zero dependencies!)
+- **Optional**: `structlog>=23.0.0` (for logging behaviors)
+
+## License
+
+MIT

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/gridflow_python_mediator/__init__.py
+src/gridflow_python_mediator/mediator.py
+src/gridflow_python_mediator.egg-info/PKG-INFO
+src/gridflow_python_mediator.egg-info/SOURCES.txt
+src/gridflow_python_mediator.egg-info/dependency_links.txt
+src/gridflow_python_mediator.egg-info/requires.txt
+src/gridflow_python_mediator.egg-info/top_level.txt
+src/gridflow_python_mediator/behaviors/__init__.py
+src/gridflow_python_mediator/behaviors/observability.py
+src/gridflow_python_mediator/behaviors/protocol.py
+src/gridflow_python_mediator/behaviors/validation_behavior.py
+tests/test_mediator.py

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+
+[logging]
+structlog>=23.0.0

gridflow_python_mediator-0.1.0/src/gridflow_python_mediator.egg-info/top_level.txt

@@ -0,0 +1 @@
+gridflow_python_mediator

gridflow_python_mediator-0.1.0/tests/test_mediator.py

@@ -0,0 +1,105 @@
+"""Unit tests for Mediator class.
+
+Tests core mediator functionality including handler registration and dispatch.
+RULE: Maximum 100 lines per file.
+"""
+
+import pytest
+from gridflow_python_mediator import Mediator
+
+
+class SampleRequest:
+    """Sample request for testing."""
+    def __init__(self, value: str):
+        self.value = value
+
+
+class SampleHandler:
+    """Sample handler for testing."""
+    async def handle(self, request: SampleRequest) -> str:
+        return f"Handled: {request.value}"
+
+
+class AnotherRequest:
+    """Another request for testing."""
+    pass
+
+
+def test_mediator_initialization():
+    """Should initialize with empty handlers and behaviors."""
+    mediator = Mediator()
+    
+    assert mediator._handlers == {}
+    assert mediator._behaviors == []
+
+
+def test_register_handler():
+    """Should register handler for request type."""
+    mediator = Mediator()
+    handler = SampleHandler()
+    
+    mediator.register_handler(SampleRequest, handler)
+    
+    assert SampleRequest in mediator._handlers
+    assert mediator._handlers[SampleRequest] is handler
+
+
+def test_register_duplicate_handler_raises():
+    """Should raise on duplicate handler registration."""
+    mediator = Mediator()
+    handler = SampleHandler()
+    
+    mediator.register_handler(SampleRequest, handler)
+    
+    with pytest.raises(ValueError, match="Handler already registered"):
+        mediator.register_handler(SampleRequest, handler)
+
+
+async def test_send_dispatches_to_handler():
+    """Should dispatch request to registered handler."""
+    mediator = Mediator()
+    mediator.register_handler(SampleRequest, SampleHandler())
+    
+    result = await mediator.send(SampleRequest("test"))
+    
+    assert result == "Handled: test"
+
+
+async def test_send_unregistered_raises():
+    """Should raise on unregistered request type."""
+    mediator = Mediator()
+    
+    with pytest.raises(ValueError, match="No handler registered"):
+        await mediator.send(AnotherRequest())
+
+
+async def test_add_pipeline_behavior():
+    """Should execute pipeline behaviors before handler."""
+    mediator = Mediator()
+    mediator.register_handler(SampleRequest, SampleHandler())
+    
+    called = []
+    
+    async def logging_behavior(request, handler):
+        called.append("behavior")
+        return None  # Continue to handler
+    
+    mediator.add_pipeline_behavior(logging_behavior)
+    result = await mediator.send(SampleRequest("test"))
+    
+    assert "behavior" in called
+    assert result == "Handled: test"
+
+
+async def test_pipeline_behavior_short_circuit():
+    """Should allow behavior to short-circuit handler."""
+    mediator = Mediator()
+    mediator.register_handler(SampleRequest, SampleHandler())
+    
+    async def short_circuit_behavior(request, handler):
+        return "Short-circuited"
+    
+    mediator.add_pipeline_behavior(short_circuit_behavior)
+    result = await mediator.send(SampleRequest("test"))
+    
+    assert result == "Short-circuited"