exonware-xwsystem 0.1.0.1__py3-none-any.whl → 0.1.0.4__py3-none-any.whl

exonware/xwsystem/threading/defs.py

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

exonware/xwsystem/threading/errors.py

@@ -1,9 +1,10 @@
+#exonware/xwsystem/src/exonware/xwsystem/threading/errors.py
 #exonware/xwsystem/threading/errors.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generation Date: September 04, 2025
 
 Threading module errors - exception classes for threading functionality.

exonware/xwsystem/threading/facade.py

@@ -0,0 +1,175 @@
+#exonware/xwsystem/src/exonware/xwsystem/threading/facade.py
+"""
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.4
+Generation Date: January 2026
+
+XWConcurrency - Unified Concurrency Facade
+
+Simplified API for threading and concurrency:
+- Thread-safe factories
+- Async primitives
+- Thread pools
+- Process pools
+"""
+
+from typing import Any, Optional, Callable, List
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+
+from .safe_factory import ThreadSafeFactory, MethodGenerator
+from .async_primitives import (
+    AsyncLock,
+    AsyncSemaphore,
+    AsyncEvent,
+    AsyncQueue,
+    AsyncCondition,
+    AsyncResourcePool,
+)
+from ..config.logging_setup import get_logger
+
+logger = get_logger(__name__)
+
+
+class XWConcurrency:
+    """
+    Unified concurrency facade - simple API for threading operations.
+    
+    Examples:
+        >>> # Thread-safe factory
+        >>> factory = XWConcurrency.Factory()
+        >>> factory.register("handler", MyHandler, thread_safe=True)
+        
+        >>> # Async primitives
+        >>> lock = XWConcurrency.Lock()
+        >>> queue = XWConcurrency.Queue()
+        >>> semaphore = XWConcurrency.Semaphore(5)
+        
+        >>> # Thread pool
+        >>> with XWConcurrency.Pool(workers=4) as pool:
+        ...     results = pool.map(process_item, items)
+        
+        >>> # Process pool
+        >>> with XWConcurrency.ProcessPool(workers=4) as pool:
+        ...     results = pool.map(cpu_intensive_task, items)
+    """
+    
+    class Factory:
+        """Thread-safe factory."""
+        
+        def __init__(self):
+            self._factory = ThreadSafeFactory()
+        
+        def register(self, name: str, handler_class: type, thread_safe: bool = True) -> None:
+            """Register handler with factory."""
+            # ThreadSafeFactory.register doesn't take thread_safe parameter
+            self._factory.register(name, handler_class)
+        
+        def get(self, name: str, *args, **kwargs) -> Any:
+            """Get handler instance."""
+            # ThreadSafeFactory uses create() method, not get()
+            handler_class = self._factory.get_handler(name)
+            if handler_class:
+                return handler_class(*args, **kwargs)
+            return None
+    
+    @staticmethod
+    def Lock() -> AsyncLock:
+        """Create async lock."""
+        return AsyncLock()
+    
+    @staticmethod
+    def Semaphore(value: int = 1) -> AsyncSemaphore:
+        """Create async semaphore."""
+        return AsyncSemaphore(value)
+    
+    @staticmethod
+    def Event() -> AsyncEvent:
+        """Create async event."""
+        return AsyncEvent()
+    
+    @staticmethod
+    def Queue(maxsize: int = 0) -> AsyncQueue:
+        """Create async queue."""
+        return AsyncQueue(maxsize)
+    
+    @staticmethod
+    def Condition(lock: Optional[AsyncLock] = None) -> AsyncCondition:
+        """Create async condition."""
+        return AsyncCondition(lock)
+    
+    @staticmethod
+    def ResourcePool(factory: Callable, max_size: int = 10) -> AsyncResourcePool:
+        """Create async resource pool."""
+        return AsyncResourcePool(factory, max_size)
+    
+    class Pool:
+        """Thread pool executor."""
+        
+        def __init__(self, workers: int = 4):
+            """
+            Initialize thread pool.
+            
+            Args:
+                workers: Number of worker threads
+            """
+            self.workers = workers
+            self._pool: Optional[ThreadPoolExecutor] = None
+        
+        def __enter__(self):
+            """Context manager entry."""
+            self._pool = ThreadPoolExecutor(max_workers=self.workers)
+            return self
+        
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            """Context manager exit."""
+            if self._pool:
+                self._pool.shutdown(wait=True)
+        
+        def map(self, func: Callable, items: List[Any]) -> List[Any]:
+            """Map function over items using thread pool."""
+            if not self._pool:
+                raise RuntimeError("Pool not started. Use as context manager.")
+            return list(self._pool.map(func, items))
+        
+        def submit(self, func: Callable, *args, **kwargs):
+            """Submit task to thread pool."""
+            if not self._pool:
+                raise RuntimeError("Pool not started. Use as context manager.")
+            return self._pool.submit(func, *args, **kwargs)
+    
+    class ProcessPool:
+        """Process pool executor."""
+        
+        def __init__(self, workers: int = 4):
+            """
+            Initialize process pool.
+            
+            Args:
+                workers: Number of worker processes
+            """
+            self.workers = workers
+            self._pool: Optional[ProcessPoolExecutor] = None
+        
+        def __enter__(self):
+            """Context manager entry."""
+            self._pool = ProcessPoolExecutor(max_workers=self.workers)
+            return self
+        
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            """Context manager exit."""
+            if self._pool:
+                self._pool.shutdown(wait=True)
+        
+        def map(self, func: Callable, items: List[Any]) -> List[Any]:
+            """Map function over items using process pool."""
+            if not self._pool:
+                raise RuntimeError("Pool not started. Use as context manager.")
+            return list(self._pool.map(func, items))
+        
+        def submit(self, func: Callable, *args, **kwargs):
+            """Submit task to process pool."""
+            if not self._pool:
+                raise RuntimeError("Pool not started. Use as context manager.")
+            return self._pool.submit(func, *args, **kwargs)

exonware/xwsystem/threading/locks.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/threading/locks.py
 """
 Enhanced locking utilities for thread-safe operations.
 """

exonware/xwsystem/threading/safe_factory.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/threading/safe_factory.py
 #exonware/xwsystem/threading/safe_factory.py
 """
 Thread-safe factory pattern for handler registration and management.

exonware/xwsystem/utils/__init__.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwsystem/src/exonware/xwsystem/utils/__init__.py
+
+Utilities package for xwsystem.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.4
+Generation Date: 28-Dec-2025
+"""
+
+# String utilities
+from .string import find_nth_occurrence
+
+# Web utilities
+from .web import validate_url_accessible, extract_webpage_text
+
+# DateTime utilities (re-export from dt submodule)
+from .dt import (
+    get_datetime, get_date, get_date_from_to_month, calculate_duration_days,
+    parse_timestamp_milliseconds
+)
+
+__all__ = [
+    # String utilities
+    'find_nth_occurrence',
+    
+    # Web utilities
+    'validate_url_accessible',
+    'extract_webpage_text',
+    
+    # DateTime utilities
+    'get_datetime',
+    'get_date',
+    'get_date_from_to_month',
+    'calculate_duration_days',
+    'parse_timestamp_milliseconds',
+]

exonware/xwsystem/utils/base.py

@@ -1,16 +1,17 @@
+#exonware/xwsystem/src/exonware/xwsystem/utils/base.py
 #exonware/xwsystem/utils/base.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generation Date: September 04, 2025
 
 Utils module base classes - abstract classes for utility functionality.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Optional, Union, Callable
+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 pathlib import Path
@@ -93,92 +94,92 @@ class APathUtilsBase(ABC):
         self._normalized_paths: dict[str, str] = {}
     
     @abstractmethod
-    def normalize_path(self, path: Union[str, Path]) -> Path:
+    def normalize_path(self, path: str | Path) -> Path:
         """Normalize file path."""
         pass
     
     @abstractmethod
-    def resolve_path(self, path: Union[str, Path]) -> Path:
+    def resolve_path(self, path: str | Path) -> Path:
         """Resolve file path."""
         pass
     
     @abstractmethod
-    def absolute_path(self, path: Union[str, Path]) -> Path:
+    def absolute_path(self, path: str | Path) -> Path:
         """Get absolute path."""
         pass
     
     @abstractmethod
-    def relative_path(self, path: Union[str, Path], start: Optional[Union[str, Path]] = None) -> Path:
+    def relative_path(self, path: str | Path, start: Optional[str | Path] = None) -> Path:
         """Get relative path."""
         pass
     
     @abstractmethod
-    def join_paths(self, *paths: Union[str, Path]) -> Path:
+    def join_paths(self, *paths: str | Path) -> Path:
         """Join multiple paths."""
         pass
     
     @abstractmethod
-    def split_path(self, path: Union[str, Path]) -> tuple[Path, str]:
+    def split_path(self, path: str | Path) -> tuple[Path, str]:
         """Split path into directory and filename."""
         pass
     
     @abstractmethod
-    def get_extension(self, path: Union[str, Path]) -> str:
+    def get_extension(self, path: str | Path) -> str:
         """Get file extension."""
         pass
     
     @abstractmethod
-    def get_stem(self, path: Union[str, Path]) -> str:
+    def get_stem(self, path: str | Path) -> str:
         """Get file stem."""
         pass
     
     @abstractmethod
-    def get_name(self, path: Union[str, Path]) -> str:
+    def get_name(self, path: str | Path) -> str:
         """Get file/directory name."""
         pass
     
     @abstractmethod
-    def get_parent(self, path: Union[str, Path]) -> Path:
+    def get_parent(self, path: str | Path) -> Path:
         """Get parent directory."""
         pass
     
     @abstractmethod
-    def is_absolute(self, path: Union[str, Path]) -> bool:
+    def is_absolute(self, path: str | Path) -> bool:
         """Check if path is absolute."""
         pass
     
     @abstractmethod
-    def is_relative(self, path: Union[str, Path]) -> bool:
+    def is_relative(self, path: str | Path) -> bool:
         """Check if path is relative."""
         pass
     
     @abstractmethod
-    def exists(self, path: Union[str, Path]) -> bool:
+    def exists(self, path: str | Path) -> bool:
         """Check if path exists."""
         pass
     
     @abstractmethod
-    def is_file(self, path: Union[str, Path]) -> bool:
+    def is_file(self, path: str | Path) -> bool:
         """Check if path is file."""
         pass
     
     @abstractmethod
-    def is_directory(self, path: Union[str, Path]) -> bool:
+    def is_directory(self, path: str | Path) -> bool:
         """Check if path is directory."""
         pass
     
     @abstractmethod
-    def get_size(self, path: Union[str, Path]) -> int:
+    def get_size(self, path: str | Path) -> int:
         """Get path size."""
         pass
     
     @abstractmethod
-    def get_modified_time(self, path: Union[str, Path]) -> float:
+    def get_modified_time(self, path: str | Path) -> float:
         """Get path modification time."""
         pass
     
     @abstractmethod
-    def sanitize_path(self, path: Union[str, Path]) -> str:
+    def sanitize_path(self, path: str | Path) -> str:
         """Sanitize path for security."""
         pass
 
@@ -269,7 +270,7 @@ class AConfigManagerBase(ABC):
         pass
     
     @abstractmethod
-    def save_config(self, config_name: str, file_path: Union[str, Path]) -> None:
+    def save_config(self, config_name: str, file_path: str | Path) -> None:
         """Save configuration to file."""
         pass
     

exonware/xwsystem/utils/contracts.py

@@ -1,15 +1,15 @@
+#exonware/xwsystem/src/exonware/xwsystem/utils/contracts.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generation Date: September 04, 2025
 
 Utils module contracts - interfaces and enums for utility functionality.
 """
 
-from abc import ABC, abstractmethod
-from typing import Any, Optional, Union, Callable
+from typing import Any, Optional, Callable, Protocol, runtime_checkable
 # Root cause: Migrating to Python 3.12 built-in generic syntax for consistency
 # Priority #3: Maintainability - Modern type annotations improve code clarity
 from pathlib import Path
@@ -24,161 +24,138 @@ from .defs import (
 )
 
 
-class ILazyLoader[T](ABC):
+@runtime_checkable
+class ILazyLoader[T](Protocol):
     """Interface for lazy loading operations."""
     
-    @abstractmethod
     def load(self) -> T:
         """Load the object."""
-        pass
+        ...
     
-    @abstractmethod
     def is_loaded(self) -> bool:
         """Check if object is loaded."""
-        pass
+        ...
     
-    @abstractmethod
     def unload(self) -> None:
         """Unload the object."""
-        pass
+        ...
     
-    @abstractmethod
     def reload(self) -> T:
         """Reload the object."""
-        pass
+        ...
     
-    @abstractmethod
     def get_loader_function(self) -> Callable[[], T]:
         """Get the loader function."""
-        pass
+        ...
 
 
-class IPathUtils(ABC):
+@runtime_checkable
+class IPathUtils(Protocol):
     """Interface for path utility operations."""
     
-    @abstractmethod
-    def normalize_path(self, path: Union[str, Path]) -> Path:
+    def normalize_path(self, path: str | Path) -> Path:
         """Normalize path."""
-        pass
+        ...
     
-    @abstractmethod
-    def resolve_path(self, path: Union[str, Path]) -> Path:
+    def resolve_path(self, path: str | Path) -> Path:
         """Resolve path to absolute."""
-        pass
+        ...
     
-    @abstractmethod
-    def get_path_type(self, path: Union[str, Path]) -> PathType:
+    def get_path_type(self, path: str | Path) -> PathType:
         """Get path type."""
-        pass
+        ...
     
-    @abstractmethod
-    def is_safe_path(self, path: Union[str, Path]) -> bool:
+    def is_safe_path(self, path: str | Path) -> bool:
         """Check if path is safe."""
-        pass
+        ...
     
-    @abstractmethod
-    def sanitize_path(self, path: Union[str, Path]) -> Path:
+    def sanitize_path(self, path: str | Path) -> Path:
         """Sanitize path."""
-        pass
+        ...
     
-    @abstractmethod
-    def get_relative_path(self, path: Union[str, Path], base: Union[str, Path]) -> Path:
+    def get_relative_path(self, path: str | Path, base: str | Path) -> Path:
         """Get relative path."""
-        pass
+        ...
     
-    @abstractmethod
-    def ensure_path_exists(self, path: Union[str, Path]) -> None:
+    def ensure_path_exists(self, path: str | Path) -> None:
         """Ensure path exists."""
-        pass
+        ...
 
 
-class IUtilityRegistry(ABC):
+@runtime_checkable
+class IUtilityRegistry(Protocol):
     """Interface for utility registry operations."""
     
-    @abstractmethod
     def register_utility(self, name: str, utility: Any) -> None:
         """Register utility."""
-        pass
+        ...
     
-    @abstractmethod
     def get_utility(self, name: str) -> Optional[Any]:
         """Get utility by name."""
-        pass
+        ...
     
-    @abstractmethod
     def unregister_utility(self, name: str) -> None:
         """Unregister utility."""
-        pass
+        ...
     
-    @abstractmethod
     def list_utilities(self) -> list[str]:
         """List all registered utilities."""
-        pass
+        ...
     
-    @abstractmethod
     def has_utility(self, name: str) -> bool:
         """Check if utility is registered."""
-        pass
+        ...
 
 
-class IConfigManager(ABC):
+@runtime_checkable
+class IConfigManager(Protocol):
     """Interface for configuration management."""
     
-    @abstractmethod
     def get_config(self, key: str, default: Optional[Any] = None) -> Any:
         """Get configuration value."""
-        pass
+        ...
     
-    @abstractmethod
     def set_config(self, key: str, value: Any) -> None:
         """Set configuration value."""
-        pass
+        ...
     
-    @abstractmethod
-    def load_config(self, source: Union[str, Path, dict[str, Any]]) -> None:
+    def load_config(self, source: str | Path | dict[str, Any]) -> None:
         """Load configuration from source."""
-        pass
+        ...
     
-    @abstractmethod
-    def save_config(self, destination: Union[str, Path]) -> None:
+    def save_config(self, destination: str | Path) -> None:
         """Save configuration to destination."""
-        pass
+        ...
     
-    @abstractmethod
     def get_all_config(self) -> dict[str, Any]:
         """Get all configuration."""
-        pass
+        ...
     
-    @abstractmethod
     def clear_config(self) -> None:
         """Clear all configuration."""
-        pass
+        ...
 
 
-class IResourceManager(ABC):
+@runtime_checkable
+class IResourceManager(Protocol):
     """Interface for resource management."""
     
-    @abstractmethod
     def acquire_resource(self, resource_id: str) -> Any:
         """Acquire resource."""
-        pass
+        ...
     
-    @abstractmethod
     def release_resource(self, resource_id: str) -> None:
         """Release resource."""
-        pass
+        ...
     
-    @abstractmethod
     def is_resource_available(self, resource_id: str) -> bool:
         """Check if resource is available."""
-        pass
+        ...
     
-    @abstractmethod
     def get_resource_count(self) -> int:
         """Get total resource count."""
-        pass
+        ...
     
-    @abstractmethod
     def get_available_resources(self) -> list[str]:
         """Get list of available resources."""
-        pass
+        ...

exonware/xwsystem/utils/dt/__init__.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/utils/dt/__init__.py
 """
 DateTime Utilities
 =================
@@ -7,7 +8,7 @@ Production-grade datetime utilities for XSystem.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generated: 2025-01-27
 """
 
@@ -15,7 +16,11 @@ from .humanize import (
     humanize_timedelta, humanize_timestamp, time_ago, time_until,
     duration_to_human, parse_human_duration
 )
-from .parsing import parse_datetime, parse_date, parse_time, parse_iso8601, parse_timestamp
+from .parsing import parse_datetime, parse_date, parse_time, parse_iso8601, parse_timestamp, parse_timestamp_milliseconds
+from .formatting import (
+    format_datetime, format_date, format_time, format_iso8601, format_relative,
+    get_datetime, get_date, get_date_from_to_month, calculate_duration_days
+)
 
 # Placeholder imports for timezone utilities (not yet implemented)
 class TimezoneManager:
@@ -53,11 +58,22 @@ __all__ = [
     'parse_time',
     'parse_iso8601',
     'parse_timestamp',
+    'parse_timestamp_milliseconds',
+    
+    # Formatting
+    'format_datetime',
+    'format_date',
+    'format_time',
+    'format_iso8601',
+    'format_relative',
+    'get_datetime',
+    'get_date',
+    'get_date_from_to_month',
+    'calculate_duration_days',
     
     # Timezone (placeholders)
     'TimezoneManager',
     'convert_timezone',
     'get_timezone_info',
     'list_timezones',
-    'format_datetime',
 ]