provide-foundation 0.0.0.dev0__py3-none-any.whl → 0.0.0.dev2__py3-none-any.whl

provide/foundation/errors/decorators.py

@@ -7,13 +7,9 @@ fallback, and error suppression.
 from collections.abc import Callable
 import functools
 import inspect
-import time
 from typing import Any, TypeVar
 
-from attrs import define, field
-
 from provide.foundation.errors.base import FoundationError
-from provide.foundation.errors.types import RetryPolicy
 
 F = TypeVar("F", bound=Callable[..., Any])
 
@@ -148,125 +144,6 @@ def with_error_handling(
         return decorator(func)
 
 
-def retry_on_error(
-    *exceptions: type[Exception],
-    policy: RetryPolicy | None = None,
-    max_attempts: int | None = None,
-    delay: float | None = None,
-    backoff: float | None = None,
-    on_retry: Callable[[int, Exception], None] | None = None,
-) -> Callable[[F], F]:
-    """Decorator for retrying operations on specific errors.
-
-    Args:
-        *exceptions: Exception types to retry on (all if empty).
-        policy: Complete retry policy (overrides other retry params).
-        max_attempts: Maximum retry attempts (ignored if policy provided).
-        delay: Base delay between retries in seconds.
-        backoff: Backoff multiplier for delays.
-        on_retry: Callback function called before each retry.
-
-    Returns:
-        Decorated function.
-
-    Examples:
-        >>> @retry_on_error(ConnectionError, TimeoutError, max_attempts=3)
-        ... def fetch_data():
-        ...     return api_call()
-
-        >>> @retry_on_error(
-        ...     policy=RetryPolicy(max_attempts=5, backoff="exponential")
-        ... )
-        ... def unreliable_operation():
-        ...     pass
-    """
-    # Use provided policy or create one from parameters
-    if policy is None:
-        from provide.foundation.errors.types import BackoffStrategy
-
-        # Determine backoff strategy
-        if backoff is not None and backoff > 1:
-            backoff_strategy = BackoffStrategy.EXPONENTIAL
-        elif backoff == 1:
-            backoff_strategy = BackoffStrategy.FIXED
-        else:
-            backoff_strategy = BackoffStrategy.EXPONENTIAL
-
-        policy = RetryPolicy(
-            max_attempts=max_attempts or 3,
-            base_delay=delay or 1.0,
-            backoff=backoff_strategy,
-            retryable_errors=exceptions if exceptions else None,
-        )
-
-    def decorator(func: F) -> F:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            last_exception = None
-
-            for attempt in range(1, policy.max_attempts + 1):
-                try:
-                    return func(*args, **kwargs)
-                except Exception as e:
-                    last_exception = e
-
-                    # Check if we should retry this error
-                    if not policy.should_retry(e, attempt):
-                        if attempt > 1:  # Only log if we've actually retried
-                            _get_logger().error(
-                                f"All {attempt} retry attempts failed for {func.__name__}",
-                                attempts=attempt,
-                                error=str(e),
-                                error_type=type(e).__name__,
-                            )
-                        raise
-
-                    # Don't retry on last attempt
-                    if attempt >= policy.max_attempts:
-                        _get_logger().error(
-                            f"All {policy.max_attempts} retry attempts failed for {func.__name__}",
-                            attempts=policy.max_attempts,
-                            error=str(e),
-                            error_type=type(e).__name__,
-                        )
-                        raise
-
-                    # Calculate delay
-                    retry_delay = policy.calculate_delay(attempt)
-
-                    # Log retry attempt
-                    _get_logger().warning(
-                        f"Retry {attempt}/{policy.max_attempts} for {func.__name__} after {retry_delay:.2f}s",
-                        function=func.__name__,
-                        attempt=attempt,
-                        max_attempts=policy.max_attempts,
-                        delay=retry_delay,
-                        error=str(e),
-                        error_type=type(e).__name__,
-                    )
-
-                    # Call retry callback if provided
-                    if on_retry:
-                        try:
-                            on_retry(attempt, e)
-                        except Exception as callback_error:
-                            _get_logger().warning(
-                                f"Retry callback failed: {callback_error}",
-                                function=func.__name__,
-                                attempt=attempt,
-                            )
-
-                    # Wait before retry
-                    time.sleep(retry_delay)
-
-            # Should never reach here, but just in case
-            if last_exception:
-                raise last_exception
-
-        return wrapper  # type: ignore
-
-    return decorator
-
 
 def suppress_and_log(
     *exceptions: type[Exception],
@@ -374,111 +251,3 @@ def fallback_on_error(
     return decorator
 
 
-@define(kw_only=True, slots=True)
-class CircuitBreaker:
-    """Circuit breaker pattern for preventing cascading failures.
-
-    Attributes:
-        failure_threshold: Number of failures before opening circuit.
-        recovery_timeout: Seconds to wait before attempting recovery.
-        expected_exception: Exception types that trigger the breaker.
-    """
-
-    failure_threshold: int = 5
-    recovery_timeout: float = 60.0
-    expected_exception: tuple[type[Exception], ...] = field(default=(Exception,))
-
-    # Internal state
-    _failure_count: int = field(init=False, default=0)
-    _last_failure_time: float | None = field(init=False, default=None)
-    _state: str = field(init=False, default="closed")  # closed, open, half_open
-
-    def __call__(self, func: F) -> F:
-        """Decorator to apply circuit breaker to a function."""
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            # Check circuit state
-            if self._state == "open":
-                # Check if we should try half-open
-                if (
-                    self._last_failure_time
-                    and (time.time() - self._last_failure_time) > self.recovery_timeout
-                ):
-                    self._state = "half_open"
-                    _get_logger().info(
-                        f"Circuit breaker for {func.__name__} entering half-open state",
-                        function=func.__name__,
-                    )
-                else:
-                    raise RuntimeError(f"Circuit breaker is open for {func.__name__}")
-
-            try:
-                result = func(*args, **kwargs)
-
-                # Success - reset on half-open or reduce failure count
-                if self._state == "half_open":
-                    self._state = "closed"
-                    self._failure_count = 0
-                    _get_logger().info(
-                        f"Circuit breaker for {func.__name__} closed after successful recovery",
-                        function=func.__name__,
-                    )
-                elif self._failure_count > 0:
-                    self._failure_count = max(0, self._failure_count - 1)
-
-                return result
-
-            except self.expected_exception as e:
-                self._failure_count += 1
-                self._last_failure_time = time.time()
-
-                # Check if we should open the circuit
-                if self._failure_count >= self.failure_threshold:
-                    self._state = "open"
-                    _get_logger().error(
-                        f"Circuit breaker for {func.__name__} opened after {self._failure_count} failures",
-                        function=func.__name__,
-                        failures=self._failure_count,
-                        error=str(e),
-                    )
-                else:
-                    _get_logger().warning(
-                        f"Circuit breaker for {func.__name__} failure {self._failure_count}/{self.failure_threshold}",
-                        function=func.__name__,
-                        failures=self._failure_count,
-                        threshold=self.failure_threshold,
-                        error=str(e),
-                    )
-
-                raise
-
-        return wrapper  # type: ignore
-
-
-def circuit_breaker(
-    failure_threshold: int = 5,
-    recovery_timeout: float = 60.0,
-    expected_exception: tuple[type[Exception], ...] = (Exception,),
-) -> Callable[[F], F]:
-    """Create a circuit breaker decorator.
-
-    Args:
-        failure_threshold: Number of failures before opening circuit.
-        recovery_timeout: Seconds to wait before attempting recovery.
-        expected_exception: Exception types that trigger the breaker.
-
-    Returns:
-        Circuit breaker decorator.
-
-    Examples:
-        >>> @circuit_breaker(failure_threshold=3, recovery_timeout=30)
-        ... def unreliable_service():
-        ...     return external_api_call()
-    """
-    breaker = CircuitBreaker(
-        failure_threshold=failure_threshold,
-        recovery_timeout=recovery_timeout,
-        expected_exception=expected_exception,
-    )
-    return breaker

provide/foundation/errors/types.py

@@ -118,103 +118,6 @@ class ErrorMetadata:
         return result
 
 
-class BackoffStrategy(str, Enum):
-    """Backoff strategies for retry policies."""
-
-    FIXED = "fixed"  # Fixed delay between retries
-    LINEAR = "linear"  # Linear increase (delay * attempt)
-    EXPONENTIAL = "exponential"  # Exponential increase (delay * 2^attempt)
-    FIBONACCI = "fibonacci"  # Fibonacci sequence delays
-
-
-@define(kw_only=True, slots=True)
-class RetryPolicy:
-    """Configuration for retry behavior on errors.
-
-    Attributes:
-        max_attempts: Maximum number of retry attempts.
-        backoff: Backoff strategy to use.
-        base_delay: Base delay in seconds between retries.
-        max_delay: Maximum delay in seconds (caps exponential growth).
-        jitter: Whether to add random jitter to delays.
-        retryable_errors: Optional tuple of exception types to retry on.
-
-    Examples:
-        >>> policy = RetryPolicy(
-        ...     max_attempts=5,
-        ...     backoff=BackoffStrategy.EXPONENTIAL,
-        ...     base_delay=1.0,
-        ...     max_delay=30.0
-        ... )
-    """
-
-    max_attempts: int = 3
-    backoff: BackoffStrategy = BackoffStrategy.EXPONENTIAL
-    base_delay: float = 1.0
-    max_delay: float = 60.0
-    jitter: bool = True
-    retryable_errors: tuple[type[Exception], ...] | None = None
-
-    def calculate_delay(self, attempt: int) -> float:
-        """Calculate delay for a given attempt number.
-
-        Args:
-            attempt: Attempt number (1-based).
-
-        Returns:
-            Delay in seconds.
-        """
-        if attempt <= 0:
-            return 0
-
-        if self.backoff == BackoffStrategy.FIXED:
-            delay = self.base_delay
-        elif self.backoff == BackoffStrategy.LINEAR:
-            delay = self.base_delay * attempt
-        elif self.backoff == BackoffStrategy.EXPONENTIAL:
-            delay = self.base_delay * (2 ** (attempt - 1))
-        elif self.backoff == BackoffStrategy.FIBONACCI:
-            # Calculate fibonacci number for attempt
-            a, b = 0, 1
-            for _ in range(attempt):
-                a, b = b, a + b
-            delay = self.base_delay * a
-        else:
-            delay = self.base_delay
-
-        # Cap at max delay
-        delay = min(delay, self.max_delay)
-
-        # Add jitter if configured (±25% random variation)
-        if self.jitter:
-            import random
-
-            jitter_factor = 0.75 + (random.random() * 0.5)
-            delay *= jitter_factor
-
-        return delay
-
-    def should_retry(self, error: Exception, attempt: int) -> bool:
-        """Determine if an error should be retried.
-
-        Args:
-            error: The exception that occurred.
-            attempt: Current attempt number (1-based).
-
-        Returns:
-            True if should retry, False otherwise.
-        """
-        # Check attempt limit
-        if attempt >= self.max_attempts:
-            return False
-
-        # Check error type if filter is configured
-        if self.retryable_errors is not None:
-            return isinstance(error, self.retryable_errors)
-
-        # Default to retry for any error
-        return True
-
 
 @define(kw_only=True, slots=True)
 class ErrorResponse:

provide/foundation/eventsets/display.py

@@ -0,0 +1,84 @@
+"""
+Event set display utilities for Foundation.
+"""
+
+from provide.foundation.logger import get_logger
+
+from provide.foundation.eventsets.registry import get_registry, discover_event_sets
+from provide.foundation.eventsets.resolver import get_resolver
+
+logger = get_logger(__name__)
+
+
+def show_event_matrix() -> None:
+    """
+    Display the active event set configuration to the console.
+    Shows all registered event sets and their field mappings.
+    """
+    # Ensure event sets are discovered
+    discover_event_sets()
+    
+    registry = get_registry()
+    resolver = get_resolver()
+    
+    # Force resolution to ensure everything is loaded
+    resolver.resolve()
+    
+    lines: list[str] = ["Foundation Event Sets: Active Configuration"]
+    lines.append("=" * 70)
+    
+    # Show registered event sets
+    event_sets = registry.list_event_sets()
+    if event_sets:
+        lines.append(f"\nRegistered Event Sets ({len(event_sets)}):")
+        for config in event_sets:
+            lines.append(f"\n  {config.name} (priority: {config.priority})")
+            if config.description:
+                lines.append(f"    {config.description}")
+            
+            # Show field mappings
+            if config.field_mappings:
+                lines.append(f"    Field Mappings ({len(config.field_mappings)}):")
+                for mapping in config.field_mappings[:5]:  # Show first 5
+                    lines.append(f"      - {mapping.log_key}")
+                if len(config.field_mappings) > 5:
+                    lines.append(f"      ... and {len(config.field_mappings) - 5} more")
+            
+            # Show event sets
+            if config.event_sets:
+                lines.append(f"    Event Sets ({len(config.event_sets)}):")
+                for event_set in config.event_sets:
+                    marker_count = len(event_set.visual_markers)
+                    metadata_count = len(event_set.metadata_fields)
+                    transform_count = len(event_set.transformations)
+                    lines.append(
+                        f"      - {event_set.name}: "
+                        f"{marker_count} markers, "
+                        f"{metadata_count} metadata, "
+                        f"{transform_count} transforms"
+                    )
+    else:
+        lines.append("\n  (No event sets registered)")
+    
+    lines.append("\n" + "=" * 70)
+    
+    # Show resolved state
+    if resolver._resolved:
+        lines.append("\nResolver State:")
+        lines.append(f"  Total Field Mappings: {len(resolver._field_mappings)}")
+        lines.append(f"  Total Event Sets: {len(resolver._event_sets)}")
+        
+        # Show sample visual markers
+        if resolver._event_sets:
+            lines.append("\n  Sample Visual Markers:")
+            for name, event_set in list(resolver._event_sets.items())[:3]:
+                if event_set.visual_markers:
+                    sample_markers = list(event_set.visual_markers.items())[:3]
+                    lines.append(f"    {name}:")
+                    for key, marker in sample_markers:
+                        lines.append(f"      {marker} -> {key}")
+    else:
+        lines.append("\n  (Resolver not yet initialized)")
+    
+    # Log the complete display
+    logger.info("\n".join(lines))

provide/foundation/eventsets/registry.py

@@ -0,0 +1,160 @@
+"""
+Event set registry and discovery.
+"""
+
+import importlib
+import pkgutil
+from pathlib import Path
+
+from provide.foundation.errors.resources import AlreadyExistsError, NotFoundError
+from provide.foundation.hub.registry import Registry
+from provide.foundation.logger.setup.coordinator import create_foundation_internal_logger
+
+from provide.foundation.eventsets.types import EventSet
+
+# Bootstrap logger that doesn't trigger full logger setup
+logger = create_foundation_internal_logger()
+
+
+class EventSetRegistry(Registry):
+    """
+    Registry for event set definitions using foundation Registry.
+    
+    Extends the foundation Registry to provide specialized
+    methods for event set registration and discovery.
+    """
+    
+    def register_event_set(self, event_set: EventSet) -> None:
+        """
+        Register an event set definition.
+        
+        Args:
+            event_set: The EventSet to register
+            
+        Raises:
+            AlreadyExistsError: If an event set with this name already exists
+        """
+        try:
+            self.register(event_set.name, event_set, "eventset", metadata={"priority": event_set.priority})
+            logger.debug(
+                "Registered event set",
+                name=event_set.name,
+                priority=event_set.priority,
+                field_count=len(event_set.field_mappings),
+                mapping_count=len(event_set.mappings)
+            )
+        except AlreadyExistsError:
+            logger.warning("Event set already registered", name=event_set.name)
+            raise
+    
+    def get_event_set(self, name: str) -> EventSet:
+        """
+        Retrieve an event set by name.
+        
+        Args:
+            name: The name of the event set
+            
+        Returns:
+            The EventSet
+            
+        Raises:
+            NotFoundError: If no event set with this name exists
+        """
+        event_set = self.get(name, "eventset")
+        if event_set is None:
+            raise NotFoundError(f"Event set '{name}' not found")
+        return event_set
+    
+    def list_event_sets(self) -> list[EventSet]:
+        """
+        List all registered event sets sorted by priority.
+        
+        Returns:
+            List of EventSet objects sorted by descending priority
+        """
+        names = self.list_dimension("eventset")
+        entries = [self.get_entry(name, "eventset") for name in names]
+        entries = [entry for entry in entries if entry is not None]
+        entries.sort(key=lambda e: e.metadata.get("priority", 0), reverse=True)
+        return [entry.value for entry in entries]
+    
+    def discover_sets(self) -> None:
+        """
+        Auto-discover and register event sets from the sets/ directory.
+        
+        Imports all modules in the sets/ subdirectory and registers
+        any EVENT_SET constants found.
+        """
+        sets_path = Path(__file__).parent / "sets"
+        if not sets_path.exists():
+            logger.debug("No sets directory found for auto-discovery")
+            return
+        
+        for module_info in pkgutil.iter_modules([str(sets_path)]):
+            if module_info.ispkg:
+                continue
+                
+            module_name = f"provide.foundation.eventsets.sets.{module_info.name}"
+            try:
+                module = importlib.import_module(module_name)
+                
+                if hasattr(module, "EVENT_SET"):
+                    event_set = getattr(module, "EVENT_SET")
+                    if isinstance(event_set, EventSet):
+                        try:
+                            self.register_event_set(event_set)
+                            logger.debug(
+                                "Auto-discovered event set",
+                                module=module_name,
+                                name=event_set.name
+                            )
+                        except AlreadyExistsError:
+                            logger.debug(
+                                "Event set already registered during discovery",
+                                module=module_name,
+                                name=event_set.name
+                            )
+                    else:
+                        logger.warning(
+                            "EVENT_SET is not an EventSet",
+                            module=module_name,
+                            type=type(event_set).__name__
+                        )
+                        
+            except ImportError as e:
+                logger.debug(
+                    "Failed to import event set module",
+                    module=module_name,
+                    error=str(e)
+                )
+            except Exception as e:
+                logger.warning(
+                    "Error during event set discovery",
+                    module=module_name,
+                    error=str(e),
+                    error_type=type(e).__name__
+                )
+
+
+# Global registry instance
+_registry = EventSetRegistry()
+
+
+def get_registry() -> EventSetRegistry:
+    """Get the global event set registry instance."""
+    return _registry
+
+
+def register_event_set(event_set: EventSet) -> None:
+    """
+    Register an event set in the global registry.
+    
+    Args:
+        event_set: The EventSet to register
+    """
+    _registry.register_event_set(event_set)
+
+
+def discover_event_sets() -> None:
+    """Auto-discover and register all event sets."""
+    _registry.discover_sets()