provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/eventsets/registry.py

@@ -3,14 +3,15 @@ Event set registry and discovery.
 """
 
 import importlib
-import pkgutil
 from pathlib import Path
+import pkgutil
 
 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
+from provide.foundation.hub.registry import Registry
+from provide.foundation.logger.setup.coordinator import (
+    create_foundation_internal_logger,
+)
 
 # Bootstrap logger that doesn't trigger full logger setup
 logger = create_foundation_internal_logger()
@@ -19,44 +20,49 @@ 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})
+            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)
+                mapping_count=len(event_set.mappings),
             )
         except AlreadyExistsError:
-            logger.warning("Event set already registered", name=event_set.name)
+            logger.trace("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
         """
@@ -64,11 +70,11 @@ class EventSetRegistry(Registry):
         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
         """
@@ -77,11 +83,11 @@ class EventSetRegistry(Registry):
         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.
         """
@@ -89,15 +95,15 @@ class EventSetRegistry(Registry):
         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):
@@ -106,38 +112,39 @@ class EventSetRegistry(Registry):
                             logger.debug(
                                 "Auto-discovered event set",
                                 module=module_name,
-                                name=event_set.name
+                                name=event_set.name,
                             )
                         except AlreadyExistsError:
-                            logger.debug(
+                            logger.trace(
                                 "Event set already registered during discovery",
                                 module=module_name,
-                                name=event_set.name
+                                name=event_set.name,
                             )
                     else:
                         logger.warning(
                             "EVENT_SET is not an EventSet",
                             module=module_name,
-                            type=type(event_set).__name__
+                            type=type(event_set).__name__,
                         )
-                        
+
             except ImportError as e:
                 logger.debug(
                     "Failed to import event set module",
                     module=module_name,
-                    error=str(e)
+                    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__
+                    error_type=type(e).__name__,
                 )
 
 
 # Global registry instance
 _registry = EventSetRegistry()
+_discovery_completed = False
 
 
 def get_registry() -> EventSetRegistry:
@@ -148,7 +155,7 @@ def get_registry() -> EventSetRegistry:
 def register_event_set(event_set: EventSet) -> None:
     """
     Register an event set in the global registry.
-    
+
     Args:
         event_set: The EventSet to register
     """
@@ -157,4 +164,27 @@ def register_event_set(event_set: EventSet) -> None:
 
 def discover_event_sets() -> None:
     """Auto-discover and register all event sets."""
-    _registry.discover_sets()
+    global _discovery_completed
+    if _discovery_completed:
+        logger.trace("Event set discovery already completed, skipping")
+        return
+    
+    logger.debug("Starting event set discovery")
+    _registry.discover_sets()
+    _discovery_completed = True
+    logger.debug("Event set discovery completed")
+
+
+def reset_discovery_state() -> None:
+    """Reset discovery state for testing."""
+    global _discovery_completed
+    _discovery_completed = False
+    logger.trace("Event set discovery state reset")
+
+
+def clear_registry() -> None:
+    """Clear the registry for testing."""
+    global _registry, _discovery_completed
+    _registry = EventSetRegistry()
+    _discovery_completed = False
+    logger.trace("Event set registry cleared")

provide/foundation/eventsets/resolver.py

@@ -5,168 +5,172 @@ Event set resolution and enrichment logic.
 from typing import Any
 
 from provide.foundation.eventsets.registry import get_registry
-from provide.foundation.eventsets.types import EventMapping, EventSet, FieldMapping
+from provide.foundation.eventsets.types import EventMapping, FieldMapping
 
 
 class EventSetResolver:
     """
     Resolves and applies event set enrichments to log events.
     """
-    
+
     def __init__(self) -> None:
         """Initialize the resolver with cached configurations."""
         self._field_mappings: list[FieldMapping] = []
         self._event_mappings_by_set: dict[str, list[EventMapping]] = {}
         self._resolved = False
-    
+
     def resolve(self) -> None:
         """
         Resolve all registered event sets into a unified configuration.
-        
+
         This merges all registered event sets by priority, building
         the field mapping and event mapping lookup tables.
         """
         registry = get_registry()
         event_sets = registry.list_event_sets()  # Already sorted by priority
-        
+
         # Clear existing state
         self._field_mappings.clear()
         self._event_mappings_by_set.clear()
-        
+
         # Process each event set in priority order
         for event_set in event_sets:
             # Store event mappings by event set name
             self._event_mappings_by_set[event_set.name] = event_set.mappings
-            
+
             # Add field mappings
             self._field_mappings.extend(event_set.field_mappings)
-        
+
         self._resolved = True
-    
+
     def enrich_event(self, event_dict: dict[str, Any]) -> dict[str, Any]:
         """
         Enrich a log event with event set data.
-        
+
         Args:
             event_dict: The event dictionary to enrich
-            
+
         Returns:
             The enriched event dictionary
         """
         if not self._resolved:
             self.resolve()
-        
+
         enrichments = []
-        
+
         # Process each field in the event
         for field_key, field_value in list(event_dict.items()):
             if field_key == "event" or field_value is None:
                 continue
-                
+
             # Find appropriate event mapping for this field
             event_mapping = self._find_event_mapping_for_field(field_key, field_value)
             if not event_mapping:
                 continue
-                
+
             value_str = str(field_value).lower()
-            
+
             # Apply transformations
             if value_str in event_mapping.transformations:
                 field_value = event_mapping.transformations[value_str](field_value)
                 value_str = str(field_value).lower()
-            
+
             # Get visual marker
             visual_marker = event_mapping.visual_markers.get(
                 value_str,
-                event_mapping.visual_markers.get(event_mapping.default_key, "")
+                event_mapping.visual_markers.get(event_mapping.default_key, ""),
             )
-            
+
             if visual_marker:
                 enrichments.append(visual_marker)
-            
+
             # Apply metadata fields
             if value_str in event_mapping.metadata_fields:
-                for meta_key, meta_value in event_mapping.metadata_fields[value_str].items():
+                for meta_key, meta_value in event_mapping.metadata_fields[
+                    value_str
+                ].items():
                     if meta_key not in event_dict:
                         event_dict[meta_key] = meta_value
-        
+
         # Add visual enrichments to event message
         if enrichments:
             prefix = "".join(f"[{e}]" for e in enrichments)
             event_msg = event_dict.get("event", "")
             event_dict["event"] = f"{prefix} {event_msg}" if event_msg else prefix
-        
+
         return event_dict
-    
-    def _find_event_mapping_for_field(self, field_key: str, field_value: Any) -> EventMapping | None:
+
+    def _find_event_mapping_for_field(
+        self, field_key: str, field_value: Any
+    ) -> EventMapping | None:
         """
         Find the appropriate EventMapping for a given field.
-        
+
         This method uses a heuristic approach to match field keys to EventMappings:
         1. Direct field name mapping (e.g., "domain" -> "domain" mapping)
         2. Field prefix mapping (e.g., "http.method" -> "http_method" mapping)
         3. Field pattern matching
         """
         # First check for direct field name matches
-        simple_key = field_key.split('.')[-1]  # Get last part of dotted key
-        
+        simple_key = field_key.split(".")[-1]  # Get last part of dotted key
+
         for event_set_name, mappings in self._event_mappings_by_set.items():
             for mapping in mappings:
                 # Direct name match
                 if mapping.name == simple_key or mapping.name == field_key:
                     return mapping
-                
+
                 # Pattern matching for common cases
                 if field_key.startswith("http.") and mapping.name.startswith("http_"):
                     if field_key.replace(".", "_") == mapping.name:
                         return mapping
-                
+
                 if field_key.startswith("llm.") and mapping.name.startswith("llm_"):
                     if field_key.replace(".", "_") == mapping.name:
                         return mapping
-                
+
                 if field_key.startswith("db.") and mapping.name.startswith("db_"):
                     if field_key.replace(".", "_") == mapping.name:
                         return mapping
-                
+
                 if field_key.startswith("task.") and mapping.name.startswith("task_"):
                     if field_key.replace(".", "_") == mapping.name:
                         return mapping
-        
+
         return None
-    
+
     def get_visual_markers(self, event_dict: dict[str, Any]) -> list[str]:
         """
         Extract visual markers for an event without modifying it.
-        
+
         Args:
             event_dict: The event dictionary to analyze
-            
+
         Returns:
             List of visual markers that would be applied
         """
         if not self._resolved:
             self.resolve()
-        
+
         markers = []
-        
+
         for field_key, field_value in event_dict.items():
             if field_key == "event" or field_value is None:
                 continue
-                
+
             event_mapping = self._find_event_mapping_for_field(field_key, field_value)
             if not event_mapping:
                 continue
-                
+
             value_str = str(field_value).lower()
             marker = event_mapping.visual_markers.get(
                 value_str,
-                event_mapping.visual_markers.get(event_mapping.default_key, "")
+                event_mapping.visual_markers.get(event_mapping.default_key, ""),
             )
-            
+
             if marker:
                 markers.append(marker)
-        
+
         return markers
 
 
@@ -182,11 +186,11 @@ def get_resolver() -> EventSetResolver:
 def enrich_event(event_dict: dict[str, Any]) -> dict[str, Any]:
     """
     Enrich a log event with event set data.
-    
+
     Args:
         event_dict: The event dictionary to enrich
-        
+
     Returns:
         The enriched event dictionary
     """
-    return _resolver.enrich_event(event_dict)
+    return _resolver.enrich_event(event_dict)

provide/foundation/eventsets/sets/das.py

@@ -35,7 +35,7 @@ EVENT_SET = EventSet(
                 "payment": "💳",
                 "default": "❓",
             },
-            default_key="default"
+            default_key="default",
         ),
         EventMapping(
             name="action",
@@ -74,7 +74,7 @@ EVENT_SET = EventSet(
                 "register": "⚙️",
                 "default": "❓",
             },
-            default_key="default"
+            default_key="default",
         ),
         EventMapping(
             name="status",
@@ -100,29 +100,29 @@ EVENT_SET = EventSet(
                 "ready": "👍",
                 "default": "➡️",
             },
-            default_key="default"
+            default_key="default",
         ),
     ],
     field_mappings=[
         FieldMapping(
             log_key="domain",
             event_set_name="default",
-            description="System domain or component"
+            description="System domain or component",
         ),
         FieldMapping(
             log_key="action",
             event_set_name="default",
-            description="Action being performed"
+            description="Action being performed",
         ),
         FieldMapping(
             log_key="status",
             event_set_name="default",
-            description="Status or outcome of the action"
+            description="Status or outcome of the action",
         ),
     ],
-    priority=0
+    priority=0,
 )
 
 # Alias for backward compatibility
 das_event_set = EVENT_SET
-default_event_set = EVENT_SET
+default_event_set = EVENT_SET

provide/foundation/eventsets/sets/database.py

@@ -2,7 +2,7 @@
 Database operations event set for Foundation.
 """
 
-from provide.foundation.eventsets.types import EventSet, EventMapping, FieldMapping
+from provide.foundation.eventsets.types import EventMapping, EventSet, FieldMapping
 
 EVENT_SET = EventSet(
     name="database",
@@ -27,7 +27,7 @@ EVENT_SET = EventSet(
                 "redis": {"db.type": "cache", "db.vendor": "redis"},
                 "elasticsearch": {"db.type": "search", "db.vendor": "elastic"},
             },
-            default_key="default"
+            default_key="default",
         ),
         EventMapping(
             name="db_operation",
@@ -51,7 +51,7 @@ EVENT_SET = EventSet(
                 "update": {"db.write": True},
                 "delete": {"db.write": True},
             },
-            default_key="default"
+            default_key="default",
         ),
         EventMapping(
             name="db_outcome",
@@ -67,7 +67,7 @@ EVENT_SET = EventSet(
                 "error": {"db.error": True},
                 "timeout": {"db.timeout": True},
             },
-            default_key="default"
+            default_key="default",
         ),
     ],
     field_mappings=[
@@ -75,51 +75,51 @@ EVENT_SET = EventSet(
             log_key="db.system",
             event_set_name="database",
             description="Database system type",
-            value_type="string"
+            value_type="string",
         ),
         FieldMapping(
             log_key="db.operation",
             event_set_name="database",
             description="Database operation performed",
-            value_type="string"
+            value_type="string",
         ),
         FieldMapping(
             log_key="db.outcome",
             event_set_name="database",
             description="Operation outcome",
-            value_type="string"
+            value_type="string",
         ),
         FieldMapping(
             log_key="db.statement",
             event_set_name="database",
             description="SQL or query statement",
-            value_type="string"
+            value_type="string",
         ),
         FieldMapping(
             log_key="db.table",
             event_set_name="database",
             description="Table name",
             value_type="string",
-            default_override_key="default"
+            default_override_key="default",
         ),
         FieldMapping(
             log_key="db.rows_affected",
             event_set_name="database",
             description="Number of rows affected",
-            value_type="integer"
+            value_type="integer",
         ),
         FieldMapping(
             log_key="duration_ms",
             event_set_name="database",
             description="Query duration in milliseconds",
-            value_type="integer"
+            value_type="integer",
         ),
         FieldMapping(
             log_key="trace_id",
             event_set_name="database",
             description="Distributed trace ID",
-            value_type="string"
+            value_type="string",
         ),
     ],
-    priority=90
-)
+    priority=90,
+)