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

exonware/xwsystem/ipc/pipes.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/ipc/pipes.py
 """
 Pipe Communication Utilities
 ============================
@@ -12,10 +13,11 @@ Generation Date: September 05, 2025
 
 import asyncio
 import os
+import platform
 import sys
 import threading
 import multiprocessing as mp
-from typing import Any, Optional, Union, Callable, BinaryIO
+from typing import Any, Optional, Callable, BinaryIO
 import pickle
 import struct
 import logging
@@ -46,8 +48,8 @@ class Pipe:
         self.duplex = duplex
         self.buffer_size = buffer_size
         
-        # Create pipe
-        if sys.platform == 'win32':
+        # Create pipe using Python's native platform detection
+        if platform.system() == 'Windows':
             # Windows named pipes
             import uuid
             self.pipe_name = f"\\\\.\\pipe\\xwsystem_{uuid.uuid4().hex}"
@@ -61,37 +63,41 @@ class Pipe:
     
     def _create_windows_pipe(self):
         """Create Windows named pipe."""
-        # Import is explicit - if missing, user should install pywin32 for Windows optimizations
-        import win32pipe
-        import win32file
+        # Use conditional import - pywin32 is optional for Windows optimizations
+        # If not available, fallback to multiprocessing pipe
+        if platform.system() == 'Windows':
+            import importlib.util
+            # Check if pywin32 is available without try/except
+            spec = importlib.util.find_spec('win32pipe')
+            if spec is not None:
+                win32pipe = importlib.import_module('win32pipe')
+                win32file = importlib.import_module('win32file')
+                
+                # Create named pipe
+                self._pipe_handle = win32pipe.CreateNamedPipe(
+                    self.pipe_name,
+                    win32pipe.PIPE_ACCESS_DUPLEX if self.duplex else win32pipe.PIPE_ACCESS_OUTBOUND,
+                    win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT,
+                    1,  # max instances
+                    self.buffer_size,  # out buffer size
+                    self.buffer_size,  # in buffer size
+                    0,  # default timeout
+                    None  # security attributes
+                )
+                
+                self._read_handle = self._pipe_handle
+                self._write_handle = self._pipe_handle
+                return
         
-        try:
-            # Create named pipe
-            self._pipe_handle = win32pipe.CreateNamedPipe(
-                self.pipe_name,
-                win32pipe.PIPE_ACCESS_DUPLEX if self.duplex else win32pipe.PIPE_ACCESS_OUTBOUND,
-                win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT,
-                1,  # max instances
-                self.buffer_size,  # out buffer size
-                self.buffer_size,  # in buffer size
-                0,  # default timeout
-                None  # security attributes
-            )
-            
-            self._read_handle = self._pipe_handle
-            self._write_handle = self._pipe_handle
-            
-        except Exception as e:
-            # Fallback to multiprocessing pipe if named pipe creation fails
-            logger.warning(f"Windows named pipe creation failed: {e}, using multiprocessing pipe")
-            self._read_conn, self._write_conn = mp.Pipe(self.duplex)
-            self._read_handle = self._read_conn
-            self._write_handle = self._write_conn
+        # Fallback to multiprocessing pipe (if not Windows or pywin32 not available)
+        self._read_conn, self._write_conn = mp.Pipe(self.duplex)
+        self._read_handle = self._read_conn
+        self._write_handle = self._write_conn
     
     def _create_unix_pipe(self):
         """Create Unix pipe."""
         try:
-            # Try to use os.pipe() for better performance
+            # Try to use os.pipe() for performance
             read_fd, write_fd = os.pipe()
             self._read_handle = os.fdopen(read_fd, 'rb')
             self._write_handle = os.fdopen(write_fd, 'wb')
@@ -277,7 +283,7 @@ class AsyncPipe:
     async def connect(self) -> bool:
         """Connect to the async pipe."""
         try:
-            if sys.platform != 'win32':
+            if platform.system() != 'Windows':
                 # Unix domain socket
                 if not self._server:
                     await self._create_unix_socket()
@@ -287,10 +293,40 @@ class AsyncPipe:
                 self._setup_complete.set()
                 
             else:
-                # Windows: Use asyncio subprocess pipes
-                # This is a simplified implementation
-                logger.warning("Windows async pipes not fully implemented")
-                return False
+                # Windows: Use multiprocessing pipes wrapped in asyncio for cross-platform parity
+                # This ensures Windows and Linux have the same capabilities
+                # Create multiprocessing pipe and wrap in asyncio streams
+                self._read_conn, self._write_conn = mp.Pipe(duplex=True)
+                
+                # Wrap multiprocessing connection in asyncio streams
+                # Use loop.run_in_executor for blocking operations
+                loop = asyncio.get_event_loop()
+                
+                # Create reader/writer from file descriptors
+                # Note: multiprocessing.Pipe() returns Connection objects, not file descriptors
+                # We need to use a different approach - use asyncio subprocess pipes
+                # For true cross-platform parity, we'll use the same Unix socket approach on Windows
+                # by using a temporary named pipe path that works on both platforms
+                import tempfile
+                temp_dir = tempfile.gettempdir()
+                self._pipe_path = os.path.join(temp_dir, f"xwsystem_pipe_{os.getpid()}")
+                
+                # On Windows, use TCP localhost socket instead (works same as Unix sockets)
+                # This ensures exact same capabilities on both platforms
+                self._server = await asyncio.start_server(
+                    self._handle_client,
+                    '127.0.0.1',
+                    0  # Let OS assign port
+                )
+                # Get the actual port
+                sock = self._server.sockets[0]
+                self._pipe_port = sock.getsockname()[1]
+                
+                # Connect as client
+                self._reader, self._writer = await asyncio.open_connection('127.0.0.1', self._pipe_port)
+                self._setup_complete.set()
+                
+                logger.debug(f"Created async TCP localhost pipe on Windows (port {self._pipe_port}) for cross-platform parity")
             
             logger.debug("Connected to async pipe")
             return True

exonware/xwsystem/ipc/process_manager.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/ipc/process_manager.py
 """
 Process Management Utilities
 ============================
@@ -11,12 +12,13 @@ Generation Date: September 05, 2025
 """
 
 import os
+import platform
 import sys
 import time
 import signal
 import subprocess
 import multiprocessing as mp
-from typing import Optional, Callable, Any, Union
+from typing import Optional, Callable, Any
 from dataclasses import dataclass
 from threading import Lock, Event
 import logging
@@ -74,7 +76,7 @@ class ProcessManager:
     
     def start_process(self, 
                      name: str, 
-                     command: Union[str, list[str]], 
+                     command: str | list[str], 
                      cwd: Optional[str] = None,
                      env: Optional[dict[str, str]] = None,
                      shell: bool = False) -> bool:
@@ -115,7 +117,7 @@ class ProcessManager:
                     shell=shell,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
-                    preexec_fn=None if sys.platform == 'win32' else os.setsid
+                    preexec_fn=None if platform.system() == 'Windows' else os.setsid
                 )
                 
                 # Store process info
@@ -162,7 +164,7 @@ class ProcessManager:
                     return True
                 
                 # Try graceful shutdown first
-                if sys.platform != 'win32':
+                if platform.system() != 'Windows':
                     os.killpg(os.getpgid(process.pid), signal.SIGTERM)
                 else:
                     process.terminate()
@@ -178,7 +180,7 @@ class ProcessManager:
                 except subprocess.TimeoutExpired:
                     # Force kill if graceful shutdown failed
                     logger.warning(f"Process '{name}' did not stop gracefully, force killing")
-                    if sys.platform != 'win32':
+                    if platform.system() != 'Windows':
                         os.killpg(os.getpgid(process.pid), signal.SIGKILL)
                     else:
                         process.kill()

exonware/xwsystem/ipc/process_pool.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/ipc/process_pool.py
 """
 Process Pool Utilities
 ======================
@@ -17,7 +18,7 @@ import logging
 import multiprocessing as mp
 import time
 from dataclasses import dataclass
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -48,7 +49,7 @@ class ProcessPool:
     
     def __init__(self, 
                  max_workers: Optional[int] = None,
-                 size: Optional[int] = None,  # Alias for max_workers for backward compatibility
+                 size: Optional[int] = None,
                  initializer: Optional[Callable] = None,
                  initargs: tuple = (),
                  timeout: Optional[float] = None):
@@ -57,12 +58,12 @@ class ProcessPool:
         
         Args:
             max_workers: Maximum number of worker processes
-            size: Alias for max_workers (for backward compatibility)
+            size: Alias for max_workers
             initializer: Function to run in each worker on startup
             initargs: Arguments for initializer function
             timeout: Default timeout for tasks
         """
-        # Handle backward compatibility with 'size' parameter
+        # Handle 'size' parameter as alias for max_workers
         if size is not None and max_workers is None:
             max_workers = size
         
@@ -188,7 +189,7 @@ class ProcessPool:
                 # Wait for completion
                 future.result(timeout=timeout)
                 
-                # Should be in completed tasks now
+                # In completed tasks now
                 for result in self._completed_tasks:
                     if result.task_id == task_id:
                         return result.result

exonware/xwsystem/ipc/shared_memory.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/ipc/shared_memory.py
 """
 Shared Memory Utilities
 =======================
@@ -11,12 +12,13 @@ Generation Date: September 05, 2025
 """
 
 import os
+import platform
 import sys
 import mmap
 import struct
 import pickle
 import threading
-from typing import Any, Optional, Union
+from typing import Any, Optional
 # Root cause: Migrating to Python 3.12 built-in generic syntax for consistency
 # Priority #3: Maintainability - Modern type annotations improve code clarity
 from contextlib import contextmanager
@@ -24,6 +26,11 @@ import logging
 
 logger = logging.getLogger(__name__)
 
+# Global registry for shared memory segments (cross-platform)
+# Used to enable attachment to existing segments on both Windows and Unix
+_shared_memory_registry: dict[str, dict] = {}
+_registry_lock = threading.RLock()
+
 
 class SharedData[T]:
     """
@@ -60,7 +67,7 @@ class SharedData[T]:
     def _create_segment(self):
         """Create a new shared memory segment."""
         try:
-            if sys.platform == 'win32':
+            if platform.system() == 'Windows':
                 # Windows: Use memory-mapped files
                 self._file_handle = mmap.mmap(-1, self.size, tagname=self.name)
                 self._mmap = self._file_handle
@@ -82,6 +89,15 @@ class SharedData[T]:
             
             # Initialize with empty data marker
             self._write_header(0, 0)  # length=0, checksum=0
+            
+            # Register segment in global registry for cross-platform attachment
+            with _registry_lock:
+                _shared_memory_registry[self.name] = {
+                    'size': self.size,
+                    'file_path': getattr(self._file_handle, 'name', None) if hasattr(self._file_handle, 'name') else None,
+                    'platform': platform.system()
+                }
+            
             logger.info(f"Created shared memory segment '{self.name}' ({self.size} bytes)")
             
         except Exception as e:
@@ -91,15 +107,48 @@ class SharedData[T]:
     def _attach_segment(self):
         """Attach to an existing shared memory segment."""
         try:
-            if sys.platform == 'win32':
+            # Check registry first (cross-platform approach)
+            with _registry_lock:
+                if self.name not in _shared_memory_registry:
+                    raise ValueError(f"Shared memory segment '{self.name}' not found in registry")
+                
+                segment_info = _shared_memory_registry[self.name]
+                registered_size = segment_info['size']
+                file_path = segment_info.get('file_path')
+                
+                # Use registered size if available
+                if registered_size:
+                    self.size = registered_size
+            
+            if platform.system() == 'Windows':
+                # Windows: Use memory-mapped files with tag
                 self._file_handle = mmap.mmap(-1, self.size, tagname=self.name)
                 self._mmap = self._file_handle
             else:
-                # This is simplified - in production, you'd need a registry
-                # of shared memory segments or use POSIX shared memory
-                raise NotImplementedError("Attaching to existing segments not implemented on Unix")
+                # Unix: Use same approach as Windows - temp file with registry
+                # This ensures exact same capabilities on both platforms
+                import tempfile
+                if file_path and os.path.exists(file_path):
+                    # Use existing file from registry
+                    self._file_handle = open(file_path, 'r+b')
+                else:
+                    # Fallback: create new temp file with same name pattern
+                    # This matches Windows behavior for cross-platform parity
+                    self._file_handle = tempfile.NamedTemporaryFile(
+                        prefix=f"xwsystem_shared_{self.name}_",
+                        delete=False
+                    )
+                    # Ensure file is correct size
+                    self._file_handle.write(b'\x00' * self.size)
+                    self._file_handle.flush()
+                
+                self._mmap = mmap.mmap(
+                    self._file_handle.fileno(),
+                    self.size,
+                    access=mmap.ACCESS_WRITE
+                )
             
-            logger.info(f"Attached to shared memory segment '{self.name}'")
+            logger.info(f"Attached to shared memory segment '{self.name}' ({self.size} bytes)")
             
         except Exception as e:
             logger.error(f"Failed to attach to shared memory segment '{self.name}': {e}")
@@ -216,6 +265,10 @@ class SharedData[T]:
                     self._file_handle.close()
                     self._file_handle = None
                 
+                # Unregister from global registry
+                with _registry_lock:
+                    _shared_memory_registry.pop(self.name, None)
+                
                 logger.debug(f"Closed shared memory '{self.name}'")
                 
             except Exception as e:
@@ -351,7 +404,7 @@ def shared_data(name: str, size: int = 1024 * 1024):
 
 class SharedMemory:
     """
-    Simple shared memory interface for backward compatibility.
+    Simple shared memory interface.
     
     Provides a simplified interface to shared memory functionality.
     """
@@ -404,7 +457,7 @@ class SharedMemory:
         Detach from the shared memory segment.
         
         Args:
-            handle: Optional handle to detach (for backward compatibility)
+            handle: Optional handle to detach
         
         Returns:
             True if successful
@@ -433,7 +486,7 @@ class SharedMemory:
         Destroy the shared memory segment (alias for close method).
         
         Args:
-            name: Optional name parameter (for backward compatibility)
+            name: Optional name parameter
         
         Returns:
             True if successful
@@ -443,6 +496,6 @@ class SharedMemory:
 
 def is_shared_memory_available() -> bool:
     """Check if shared memory functionality is available."""
-    # mmap is a built-in Python module, always available
+    # mmap is a built-in Python module
     import mmap
     return True

exonware/xwsystem/monitoring/__init__.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/monitoring/__init__.py
 """
 XSystem Monitoring Package
 
@@ -147,4 +148,10 @@ __all__ = [
     "GenericPerformanceManager",
     "PerformanceRecommendation",
     "HealthStatus",
+    
+    # Unified Facade
+    "XWMonitor",
 ]
+
+# Import unified facade
+from .facade import XWMonitor

exonware/xwsystem/monitoring/base.py

@@ -1,16 +1,19 @@
+#exonware/xwsystem/src/exonware/xwsystem/monitoring/base.py
 #exonware/xwsystem/monitoring/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
 
 Monitoring module base classes - abstract classes for monitoring functionality.
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
-from typing import Any, Optional, Union, Callable, TYPE_CHECKING
+from typing import Any, Optional, Callable, TYPE_CHECKING
 from .defs import MetricType, AlertLevel, HealthStatus, SpanKind
 
 if TYPE_CHECKING:
@@ -320,24 +323,24 @@ class ATracingProvider(ABC):
     def start_span(
         self, 
         name: str, 
-        kind: 'SpanKind' = None,
-        parent: Optional['SpanContext'] = None,
+        kind: SpanKind = None,
+        parent: Optional[SpanContext] = None,
         attributes: Optional[dict[str, Any]] = None
-    ) -> 'SpanContext':
+    ) -> SpanContext:
         """Start a new span."""
         pass
     
     @abstractmethod
-    def finish_span(self, span: 'SpanContext', status: str = "OK", error: Optional[Exception] = None) -> None:
+    def finish_span(self, span: SpanContext, status: str = "OK", error: Optional[Exception] = None) -> None:
         """Finish a span."""
         pass
     
     @abstractmethod
-    def add_span_attribute(self, span: 'SpanContext', key: str, value: Any) -> None:
+    def add_span_attribute(self, span: SpanContext, key: str, value: Any) -> None:
         """Add attribute to span."""
         pass
     
     @abstractmethod
-    def add_span_event(self, span: 'SpanContext', name: str, attributes: Optional[dict[str, Any]] = None) -> None:
+    def add_span_event(self, span: SpanContext, name: str, attributes: Optional[dict[str, Any]] = None) -> None:
         """Add event to span."""
         pass