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

exonware/xwsystem/patterns/object_pool.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/patterns/object_pool.py
 """
 Generic object pool implementation for XSystem framework.
 
@@ -6,12 +7,12 @@ components to reduce memory allocation overhead and improve performance.
 """
 
 import threading
-from typing import Any, Callable, Dict, List, Optional, Type, TypeVar
+from typing import Any, Callable, Optional
+# Root cause: Migrating to Python 3.12 built-in generic syntax for consistency
+# Priority #3: Maintainability - Modern type annotations improve code clarity
 
 from ..config.logging_setup import get_logger
 
-T = TypeVar("T")
-
 
 class ObjectPool:
     """
@@ -35,13 +36,13 @@ class ObjectPool:
             enable_thread_safety: Whether to use thread-safe operations
             component_name: Name for logging purposes
         """
-        self._pools: Dict[Type, List[Any]] = {}
+        self._pools: dict[type, list[Any]] = {}
         self._max_size = max_size
         self._lock = threading.RLock() if enable_thread_safety else None
         self._logger = get_logger(f"{component_name}.object_pool")
         self._stats = {"created": 0, "reused": 0, "released": 0, "discarded": 0}
 
-    def get(self, obj_type: Type[T], *args, **kwargs) -> T:
+    def get[T](self, obj_type: type[T], *args, **kwargs) -> T:
         """
         Get an object from the pool or create a new one if the pool is empty.
 
@@ -61,7 +62,7 @@ class ObjectPool:
         else:
             return self._get_from_pool(obj_type, pool, *args, **kwargs)
 
-    def _get_from_pool(self, obj_type: Type[T], pool: List[Any], *args, **kwargs) -> T:
+    def _get_from_pool[T](self, obj_type: type[T], pool: list[Any], *args, **kwargs) -> T:
         """Internal method to get object from pool."""
         if pool:
             obj = pool.pop()
@@ -99,7 +100,7 @@ class ObjectPool:
         else:
             self._release_to_pool(obj, obj_type)
 
-    def _release_to_pool(self, obj: Any, obj_type: Type) -> None:
+    def _release_to_pool(self, obj: Any, obj_type: type) -> None:
         """Internal method to release object to pool."""
         if obj_type not in self._pools:
             self._pools[obj_type] = []
@@ -114,7 +115,7 @@ class ObjectPool:
             self._stats["discarded"] += 1
             self._logger.debug(f"Discarded {obj_type.__name__} (pool full)")
 
-    def clear(self, obj_type: Optional[Type] = None) -> None:
+    def clear(self, obj_type: Optional[type] = None) -> None:
         """
         Clear objects from the pool.
 
@@ -127,7 +128,7 @@ class ObjectPool:
         else:
             self._clear_pool(obj_type)
 
-    def _clear_pool(self, obj_type: Optional[Type] = None) -> None:
+    def _clear_pool(self, obj_type: Optional[type] = None) -> None:
         """Internal method to clear pool."""
         if obj_type is None:
             # Clear all pools
@@ -140,7 +141,7 @@ class ObjectPool:
                 self._pools[obj_type].clear()
                 self._logger.info(f"Cleared pool for {obj_type.__name__}")
 
-    def get_stats(self) -> Dict[str, Any]:
+    def get_stats(self) -> dict[str, Any]:
         """
         Get pool statistics.
 
@@ -153,7 +154,7 @@ class ObjectPool:
         else:
             return self._get_pool_stats()
 
-    def _get_pool_stats(self) -> Dict[str, Any]:
+    def _get_pool_stats(self) -> dict[str, Any]:
         """Internal method to get pool statistics."""
         pool_sizes = {t.__name__: len(pool) for t, pool in self._pools.items()}
 
@@ -199,7 +200,7 @@ class PooledObject:
 
 
 # Global object pool registry
-_pool_registry: Dict[str, ObjectPool] = {}
+_pool_registry: dict[str, ObjectPool] = {}
 _pool_registry_lock = threading.RLock()
 
 
@@ -242,7 +243,7 @@ def clear_object_pool(component_name: str) -> None:
             del _pool_registry[component_name]
 
 
-def get_all_pool_stats() -> Dict[str, Dict[str, Any]]:
+def get_all_pool_stats() -> dict[str, dict[str, Any]]:
     """
     Get statistics for all object pools.
 

exonware/xwsystem/patterns/registry.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/patterns/registry.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: October 26, 2025
 
 Generic registry pattern for dynamic registration and discovery.
@@ -11,25 +12,30 @@ Generic registry pattern for dynamic registration and discovery.
 
 import threading
 import time
-from typing import Any, Dict, List, Optional, Type, TypeVar, Callable, Set
+from typing import Any, Optional, Callable
+# Root cause: Migrating to Python 3.12 built-in generic syntax for consistency
+# Priority #3: Maintainability - Modern type annotations improve code clarity
 from abc import ABC, abstractmethod
 from ..config.logging_setup import get_logger
 
 logger = get_logger("xwsystem.patterns.registry")
 
-T = TypeVar('T')
-
 
 class RegistryError(Exception):
     """Registry-specific error."""
     pass
 
 
-class IRegistry(ABC):
-    """Interface for registry implementations."""
+class IRegistry[T](ABC):
+    """
+    Interface for registry implementations.
+    
+    Root cause: Adding generic type parameter for better type safety.
+    Priority #3: Maintainability - Generic types improve code clarity and type checking.
+    """
     
     @abstractmethod
-    def register(self, name: str, item: Any, metadata: Optional[Dict[str, Any]] = None) -> bool:
+    def register(self, name: str, item: T, metadata: Optional[dict[str, Any]] = None) -> bool:
         """Register an item with optional metadata."""
         pass
     
@@ -39,12 +45,12 @@ class IRegistry(ABC):
         pass
     
     @abstractmethod
-    def get(self, name: str) -> Optional[Any]:
+    def get(self, name: str) -> Optional[T]:
         """Get an item by name."""
         pass
     
     @abstractmethod
-    def list_names(self) -> List[str]:
+    def list_names(self) -> list[str]:
         """List all registered names."""
         pass
     
@@ -59,7 +65,7 @@ class IRegistry(ABC):
         pass
 
 
-class GenericRegistry(IRegistry):
+class GenericRegistry[T](IRegistry[T]):
     """
     Generic registry for dynamic registration and discovery.
     
@@ -75,7 +81,7 @@ class GenericRegistry(IRegistry):
     def __init__(
         self,
         name: str = "generic",
-        item_type: Optional[Type] = None,
+        item_type: Optional[type] = None,
         allow_overwrite: bool = False,
         auto_discovery: bool = False
     ):
@@ -97,13 +103,13 @@ class GenericRegistry(IRegistry):
         self._lock = threading.RLock()
         
         # Storage
-        self._items: Dict[str, Any] = {}
-        self._metadata: Dict[str, Dict[str, Any]] = {}
-        self._factories: Dict[str, Callable[[], Any]] = {}
+        self._items: dict[str, T] = {}
+        self._metadata: dict[str, dict[str, Any]] = {}
+        self._factories: dict[str, Callable[[], T]] = {}
         
         # Callbacks
-        self._registration_callbacks: List[Callable[[str, Any, Dict[str, Any]], None]] = []
-        self._unregistration_callbacks: List[Callable[[str, Any], None]] = []
+        self._registration_callbacks: list[Callable[[str, T, dict[str, Any]], None]] = []
+        self._unregistration_callbacks: list[Callable[[str, T], None]] = []
         
         # Statistics
         self._stats = {
@@ -119,9 +125,9 @@ class GenericRegistry(IRegistry):
     def register(
         self,
         name: str,
-        item: Any,
-        metadata: Optional[Dict[str, Any]] = None,
-        factory: Optional[Callable[[], Any]] = None
+        item: T,
+        metadata: Optional[dict[str, Any]] = None,
+        factory: Optional[Callable[[], T]] = None
     ) -> bool:
         """
         Register an item with optional metadata and factory.
@@ -229,7 +235,7 @@ class GenericRegistry(IRegistry):
                 logger.error(f"Failed to unregister item '{name}': {e}")
                 return False
     
-    def get(self, name: str) -> Optional[Any]:
+    def get(self, name: str) -> Optional[T]:
         """
         Get an item by name.
         
@@ -265,7 +271,7 @@ class GenericRegistry(IRegistry):
                 self._stats['misses'] += 1
                 return None
     
-    def list_names(self) -> List[str]:
+    def list_names(self) -> list[str]:
         """List all registered names."""
         with self._lock:
             return list(self._items.keys())
@@ -299,12 +305,12 @@ class GenericRegistry(IRegistry):
                 logger.error(f"Failed to clear registry '{self.name}': {e}")
                 return False
     
-    def get_metadata(self, name: str) -> Optional[Dict[str, Any]]:
+    def get_metadata(self, name: str) -> Optional[dict[str, Any]]:
         """Get metadata for an item."""
         with self._lock:
             return self._metadata.get(name)
     
-    def update_metadata(self, name: str, metadata: Dict[str, Any]) -> bool:
+    def update_metadata(self, name: str, metadata: dict[str, Any]) -> bool:
         """Update metadata for an item."""
         with self._lock:
             if name not in self._items:
@@ -316,17 +322,17 @@ class GenericRegistry(IRegistry):
             self._metadata[name].update(metadata)
             return True
     
-    def add_registration_callback(self, callback: Callable[[str, Any, Dict[str, Any]], None]):
+    def add_registration_callback(self, callback: Callable[[str, T, dict[str, Any]], None]):
         """Add callback for registration events."""
         with self._lock:
             self._registration_callbacks.append(callback)
     
-    def add_unregistration_callback(self, callback: Callable[[str, Any], None]):
+    def add_unregistration_callback(self, callback: Callable[[str, T], None]):
         """Add callback for unregistration events."""
         with self._lock:
             self._unregistration_callbacks.append(callback)
     
-    def get_stats(self) -> Dict[str, Any]:
+    def get_stats(self) -> dict[str, Any]:
         """Get registry statistics."""
         with self._lock:
             total_lookups = self._stats['hits'] + self._stats['misses']
@@ -346,7 +352,7 @@ class GenericRegistry(IRegistry):
                 'auto_discovery': self.auto_discovery,
             }
     
-    def discover_items(self, discovery_func: Callable[[], List[tuple]]) -> int:
+    def discover_items(self, discovery_func: Callable[[], list[tuple[str, T, dict[str, Any]]]]) -> int:
         """
         Discover and register items using a discovery function.
         
@@ -374,28 +380,35 @@ class GenericRegistry(IRegistry):
 
 
 # Global registry manager
-_registries: Dict[str, GenericRegistry] = {}
+_registries: dict[str, GenericRegistry[Any]] = {}
 _registry_lock = threading.RLock()
 
 
-def get_registry(name: str, **kwargs) -> GenericRegistry:
+def get_registry(name: str, **kwargs) -> GenericRegistry[Any]:
     """
     Get or create a registry by name.
     
+    Root cause: Global registry storage uses GenericRegistry[Any] for flexibility.
+    Users can create typed registries directly: GenericRegistry[MyType]().
+    Priority #3: Maintainability - Clear API design.
+    
     Args:
         name: Registry name
         **kwargs: Additional arguments for registry creation
         
     Returns:
-        Registry instance
+        Registry instance (untyped for global registry flexibility)
+        
+    Note:
+        For type-safe registries, create directly: GenericRegistry[MyType]()
     """
     with _registry_lock:
         if name not in _registries:
-            _registries[name] = GenericRegistry(name=name, **kwargs)
+            _registries[name] = GenericRegistry[Any](name=name, **kwargs)
         return _registries[name]
 
 
-def list_registries() -> List[str]:
+def list_registries() -> list[str]:
     """List all registry names."""
     with _registry_lock:
         return list(_registries.keys())

exonware/xwsystem/plugins/__init__.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: September 04, 2025
 
 XSystem Plugins Package

exonware/xwsystem/plugins/base.py

@@ -1,9 +1,9 @@
-#exonware/xsystem/plugins/base.py
+#exonware/xwsystem/plugins/base.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: September 04, 2025
 
 Plugin system base classes and management.
@@ -15,7 +15,7 @@ import threading
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type, Union
+from typing import Any, Optional, Union
 
 from importlib.metadata import entry_points
 
@@ -24,7 +24,7 @@ from ..runtime.reflection import ReflectionUtils
 from .contracts import IPlugin, PluginState, PluginType, PluginPriority
 from .errors import PluginError
 
-logger = get_logger("xsystem.plugins.base")
+logger = get_logger("xwsystem.plugins.base")
 
 
 @dataclass
@@ -39,8 +39,8 @@ class APluginInfo:
     class_name: str = ""
     enabled: bool = True
     priority: int = 100
-    dependencies: List[str] = field(default_factory=list)
-    metadata: Dict[str, Any] = field(default_factory=dict)
+    dependencies: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
 
 class APlugin(IPlugin):
@@ -50,7 +50,7 @@ class APlugin(IPlugin):
     Plugins should inherit from this class and implement the required methods.
     """
 
-    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
+    def __init__(self, config: Optional[dict[str, Any]] = None) -> None:
         """
         Initialize plugin with optional configuration.
 
@@ -84,7 +84,7 @@ class APlugin(IPlugin):
         return ""
 
     @property
-    def dependencies(self) -> List[str]:
+    def dependencies(self) -> list[str]:
         """List of plugin dependencies."""
         return []
 
@@ -102,7 +102,7 @@ class APlugin(IPlugin):
         """Check if plugin is initialized."""
         return self._initialized
 
-    def get_info(self) -> Dict[str, Any]:
+    def get_info(self) -> dict[str, Any]:
         """Get plugin information."""
         return {
             'name': self.name,
@@ -133,7 +133,7 @@ class APlugin(IPlugin):
         """Get plugin priority."""
         return PluginPriority.NORMAL
 
-    def get_dependencies(self) -> List[str]:
+    def get_dependencies(self) -> list[str]:
         """Get plugin dependencies."""
         return self.dependencies
 
@@ -169,9 +169,9 @@ class APluginRegistry:
 
     def __init__(self) -> None:
         """Initialize plugin registry."""
-        self._plugins: Dict[str, APlugin] = {}
-        self._plugin_info: Dict[str, APluginInfo] = {}
-        self._enabled_plugins: Set[str] = set()
+        self._plugins: dict[str, APlugin] = {}
+        self._plugin_info: dict[str, APluginInfo] = {}
+        self._enabled_plugins: set[str] = set()
         self._lock = threading.RLock()
 
     def register(self, plugin: APlugin) -> None:
@@ -234,12 +234,12 @@ class APluginRegistry:
         with self._lock:
             return self._plugins.get(plugin_name)
 
-    def get_all(self) -> Dict[str, APlugin]:
+    def get_all(self) -> dict[str, APlugin]:
         """Get all registered plugins."""
         with self._lock:
             return self._plugins.copy()
 
-    def get_enabled(self) -> Dict[str, APlugin]:
+    def get_enabled(self) -> dict[str, APlugin]:
         """Get all enabled plugins."""
         with self._lock:
             return {name: plugin for name, plugin in self._plugins.items() 
@@ -290,7 +290,7 @@ class APluginRegistry:
             logger.info(f"Disabled plugin: {plugin_name}")
             return True
 
-    def list_plugins(self) -> List[APluginInfo]:
+    def list_plugins(self) -> list[APluginInfo]:
         """Get information about all registered plugins."""
         with self._lock:
             return list(self._plugin_info.values())
@@ -326,9 +326,9 @@ class APluginManager:
             registry: Optional plugin registry to use
         """
         self.registry = registry or APluginRegistry()
-        self._discovered_plugins: Dict[str, Dict[str, Any]] = {}
+        self._discovered_plugins: dict[str, dict[str, Any]] = {}
 
-    def load_plugin_from_module(self, module_path: str, class_name: str, config: Optional[Dict[str, Any]] = None) -> APlugin:
+    def load_plugin_from_module(self, module_path: str, class_name: str, config: Optional[dict[str, Any]] = None) -> APlugin:
         """
         Load plugin from module path and class name.
 
@@ -357,7 +357,7 @@ class APluginManager:
         except Exception as e:
             raise PluginError(f"Failed to load plugin {module_path}.{class_name}: {e}") from e
 
-    def load_plugin_from_file(self, file_path: Union[str, Path], class_name: str, config: Optional[Dict[str, Any]] = None) -> APlugin:
+    def load_plugin_from_file(self, file_path: Union[str, Path], class_name: str, config: Optional[dict[str, Any]] = None) -> APlugin:
         """
         Load plugin from Python file.
 
@@ -403,7 +403,7 @@ class APluginManager:
         except Exception as e:
             raise PluginError(f"Failed to load plugin from {file_path}: {e}") from e
 
-    def discover_entry_points(self, group: str = "xsystem.plugins") -> Dict[str, Dict[str, Any]]:
+    def discover_entry_points(self, group: str = "xwsystem.plugins") -> dict[str, dict[str, Any]]:
         """
         Discover plugins through entry points.
 
@@ -439,7 +439,7 @@ class APluginManager:
             
         return discovered
 
-    def discover_directory(self, directory: Union[str, Path], pattern: str = "*.py") -> Dict[str, Dict[str, Any]]:
+    def discover_directory(self, directory: Union[str, Path], pattern: str = "*.py") -> dict[str, dict[str, Any]]:
         """
         Discover plugins in a directory.
 
@@ -492,7 +492,7 @@ class APluginManager:
             
         return discovered
 
-    def load_discovered_plugins(self, plugin_names: Optional[List[str]] = None, config: Optional[Dict[str, Dict[str, Any]]] = None) -> List[APlugin]:
+    def load_discovered_plugins(self, plugin_names: Optional[list[str]] = None, config: Optional[dict[str, dict[str, Any]]] = None) -> list[APlugin]:
         """
         Load discovered plugins.
 
@@ -539,7 +539,7 @@ class APluginManager:
         logger.info(f"Loaded {len(loaded)} plugins")
         return loaded
 
-    def initialize_plugins(self, plugin_names: Optional[List[str]] = None) -> None:
+    def initialize_plugins(self, plugin_names: Optional[list[str]] = None) -> None:
         """
         Initialize plugins with dependency resolution.
 
@@ -585,7 +585,7 @@ class APluginManager:
                 except Exception as e:
                     logger.error(f"Error shutting down plugin {plugin.name}: {e}")
 
-    def get_discovered_plugins(self) -> Dict[str, Dict[str, Any]]:
+    def get_discovered_plugins(self) -> dict[str, dict[str, Any]]:
         """Get all discovered plugins."""
         return self._discovered_plugins.copy()
 
@@ -605,7 +605,7 @@ def get_plugin_manager() -> APluginManager:
 class BasePlugin(APlugin):
     """Base plugin class for backward compatibility."""
     
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
+    def __init__(self, config: Optional[dict[str, Any]] = None):
         """Initialize base plugin."""
         super().__init__(config)
         self._name = "BasePlugin"