exonware-xwsystem 0.0.1.411__py3-none-any.whl → 0.1.0.3__py3-none-any.whl

exonware/xwsystem/caching/decorators.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/decorators.py
 #exonware/xwsystem/caching/decorators.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 01-Nov-2025
 
 Advanced cache decorators with hooks and customization.
@@ -55,8 +56,11 @@ def xwcached(
             return value * 2
     """
     # Initialize cache if not provided
+    # Use flexible create_cache() to allow configuration via environment/settings
+    # Defaults to FunctoolsLRUCache (fastest Python cache)
     if cache is None:
-        cache = LRUCache(capacity=128)
+        from .factory import create_cache
+        cache = create_cache(capacity=128, namespace='xwsystem.decorators')
     
     def decorator(func: Callable) -> Callable:
         @functools.wraps(func)
@@ -243,26 +247,9 @@ def xw_async_cache(func: Optional[Callable] = None, ttl: Optional[int] = None):
         return xw_async_cached()(func)
 
 
-# Backward compatibility aliases (deprecated, use xw-prefixed versions)
-cached = xwcached
-async_cached = xw_async_cached
-cache = xwcache
-async_cache = xw_async_cache
-cache_result = xwcache
-async_cache_result = xw_async_cache
-
-
 __all__ = [
-    # New XW-prefixed names (preferred)
     'xwcached',
     'xw_async_cached',
     'xwcache',
     'xw_async_cache',
-    # Backward compatibility (deprecated)
-    'cached',
-    'async_cached',
-    'cache',
-    'async_cache',
-    'cache_result',
-    'async_cache_result',
 ]

exonware/xwsystem/caching/defs.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/defs.py
 #exonware/xwsystem/caching/types.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 07-Sep-2025
 
 Caching types and enums for XWSystem.

exonware/xwsystem/caching/disk_cache.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/disk_cache.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: October 26, 2025
 
 Disk cache implementation with pickle-based persistence.

exonware/xwsystem/caching/distributed.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/caching/distributed.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 01-Nov-2025
 
 Distributed cache implementations - Coming in v1.0.

exonware/xwsystem/caching/errors.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/caching/errors.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: September 04, 2025
 
 Caching module errors - exception classes for caching functionality.

exonware/xwsystem/caching/events.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/events.py
 #exonware/xwsystem/caching/events.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 01-Nov-2025
 
 Event system for caching module.
@@ -14,6 +15,7 @@ Extensibility Priority #5 - Event-driven architecture for custom behaviors.
 from typing import Callable, Any, Optional
 from enum import Enum
 from ..config.logging_setup import get_logger
+from ..console import ConsoleEventLogger
 
 logger = get_logger("xwsystem.caching.events")
 
@@ -139,56 +141,138 @@ class EventLogger:
     Built-in event logger for debugging.
     
     Logs all cache events for debugging and monitoring.
+    Uses ConsoleEventLogger internally for XWUIConsole compatibility.
     """
     
-    def __init__(self, log_level: str = "DEBUG"):
+    # Map CacheEvent to ConsoleEventType
+    _CACHE_EVENT_TO_CONSOLE_TYPE = {
+        CacheEvent.HIT: 'info',
+        CacheEvent.MISS: 'warn',
+        CacheEvent.PUT: 'log',
+        CacheEvent.DELETE: 'log',
+        CacheEvent.EVICT: 'warn',
+        CacheEvent.EXPIRE: 'warn',
+        CacheEvent.CLEAR: 'system',
+        CacheEvent.ERROR: 'error',
+    }
+    
+    def __init__(self, log_level: str = "DEBUG", max_entries: int = 1000):
         """
         Initialize event logger.
         
         Args:
-            log_level: Logging level for events
+            log_level: Logging level for events (for compatibility, not used by ConsoleEventLogger)
+            max_entries: Maximum number of events to keep
         """
         self.log_level = log_level
-        self.events_log: list[dict[str, Any]] = []
+        # Use ConsoleEventLogger internally
+        self._console_logger = ConsoleEventLogger(
+            max_entries=max_entries,
+            use_milliseconds=True,
+            default_source="cache.events"
+        )
     
     def __call__(self, event: CacheEvent, **kwargs):
         """Log event."""
-        import time
-        
-        log_entry = {
-            'timestamp': time.time(),
-            'event': event.value,
-            'data': kwargs
-        }
-        
-        self.events_log.append(log_entry)
+        # Map CacheEvent to ConsoleEventType
+        console_type = self._CACHE_EVENT_TO_CONSOLE_TYPE.get(event, 'log')
         
-        # Format message
+        # Format message based on event type
         key = kwargs.get('key', '?')
         if event == CacheEvent.HIT:
-            logger.debug(f"[EVENT] Cache HIT: {key}")
+            msg = f"Cache HIT: {key}"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.MISS:
-            logger.debug(f"[EVENT] Cache MISS: {key}")
+            msg = f"Cache MISS: {key}"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.PUT:
-            logger.debug(f"[EVENT] Cache PUT: {key}")
+            msg = f"Cache PUT: {key}"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.DELETE:
-            logger.debug(f"[EVENT] Cache DELETE: {key}")
+            msg = f"Cache DELETE: {key}"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.EVICT:
-            logger.debug(f"[EVENT] Cache EVICT: {key}")
+            msg = f"Cache EVICT: {key}"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.EXPIRE:
-            logger.debug(f"[EVENT] Cache EXPIRE: {key}")
+            msg = f"Cache EXPIRE: {key}"
+            logger.debug(f"[EVENT] {msg}")
+        elif event == CacheEvent.CLEAR:
+            msg = "Cache CLEAR"
+            logger.debug(f"[EVENT] {msg}")
         elif event == CacheEvent.ERROR:
-            logger.error(f"[EVENT] Cache ERROR: {kwargs.get('error', 'Unknown')}")
+            error_msg = kwargs.get('error', 'Unknown')
+            msg = f"Cache ERROR: {error_msg}"
+            logger.error(f"[EVENT] {msg}")
+        else:
+            msg = f"Cache {event.value.upper()}: {key}"
+        
+        # Log to ConsoleEventLogger
+        # Include original cache event type in data for filtering
+        event_data = kwargs.copy()
+        event_data['_cache_event'] = event.value
+        
+        self._console_logger.add_event(
+            event_type=console_type,
+            msg=msg,
+            source="cache.events",
+            data=event_data
+        )
     
     def get_events(self, event_type: Optional[CacheEvent] = None) -> list[dict[str, Any]]:
-        """Get logged events, optionally filtered by type."""
-        if event_type:
-            return [e for e in self.events_log if e['event'] == event_type.value]
-        return self.events_log
+        """
+        Get logged events, optionally filtered by type.
+        
+        Returns events in a simplified format.
+        For XWUIConsole format, use get_console_events() instead.
+        """
+        # Get events from ConsoleEventLogger
+        console_events = self._console_logger.get_events_raw()
+        
+        # Convert to simplified format
+        result = []
+        for event in console_events:
+            # Extract original event type from data if available
+            event_data = event.data or {}
+            cache_event_value = event_data.get('_cache_event', None)
+            
+            # Filter by event_type if specified
+            if event_type is not None:
+                if cache_event_value != event_type.value:
+                    continue
+            
+            # Convert to old format
+            old_format = {
+                'timestamp': event.timestamp / 1000 if isinstance(event.timestamp, (int, float)) and event.timestamp > 1e10 else event.timestamp,
+                'event': cache_event_value or event.type,
+                'data': event.data
+            }
+            result.append(old_format)
+        
+        return result
+    
+    def get_console_events(self) -> list[dict[str, Any]]:
+        """
+        Get logged events in structured format.
+        
+        Returns:
+            List of event dictionaries in ConsoleEvent format
+        """
+        return self._console_logger.get_events()
     
     def clear(self) -> None:
         """Clear event log."""
-        self.events_log.clear()
+        self._console_logger.clear()
+    
+    @property
+    def console_logger(self) -> ConsoleEventLogger:
+        """
+        Get the underlying ConsoleEventLogger instance.
+        
+        Returns:
+            ConsoleEventLogger instance for direct access
+        """
+        return self._console_logger
 
 
 __all__ = [
@@ -196,4 +280,3 @@ __all__ = [
     'CacheEventEmitter',
     'EventLogger',
 ]
-

exonware/xwsystem/caching/eviction_strategies.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/eviction_strategies.py
 #exonware/xwsystem/caching/eviction_strategies.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 01-Nov-2025
 
 Pluggable eviction strategies for caching module.
@@ -267,4 +268,3 @@ __all__ = [
     'SizeBasedEvictionStrategy',
     'TTLEvictionStrategy',
 ]
-