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

exonware/xwsystem/io/serialization/registry.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: November 2, 2025
 
 Serialization Registry - Delegates to UniversalCodecRegistry.
@@ -10,7 +10,7 @@ Serialization Registry - Delegates to UniversalCodecRegistry.
 Provides serialization-specific convenience methods for format discovery.
 """
 
-from typing import Optional, List, Union
+from typing import Optional, Union
 from pathlib import Path
 
 from ..codec.registry import UniversalCodecRegistry, get_registry
@@ -117,7 +117,7 @@ class SerializationRegistry:
         """
         return self._codec_registry.get_by_mime_type(mime_type)
     
-    def list_formats(self) -> List[str]:
+    def list_formats(self) -> list[str]:
         """
         List all registered format IDs.
         
@@ -130,7 +130,7 @@ class SerializationRegistry:
         """
         return self._codec_registry.list_codecs()
     
-    def list_extensions(self) -> List[str]:
+    def list_extensions(self) -> list[str]:
         """
         List all registered file extensions.
         
@@ -143,7 +143,7 @@ class SerializationRegistry:
         """
         return self._codec_registry.list_extensions()
     
-    def list_mime_types(self) -> List[str]:
+    def list_mime_types(self) -> list[str]:
         """
         List all registered MIME types.
         

exonware/xwsystem/io/serialization/serializer.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
 
 XWSerializer - Unified intelligent serializer with I/O integration and auto-serialization.
@@ -11,7 +11,7 @@ XWSerializer - Unified intelligent serializer with I/O integration and auto-seri
 import os
 import time
 from pathlib import Path
-from typing import Any, Dict, Optional, Union, List, Callable, Type
+from typing import Any, Optional, Union, Callable
 
 from .base import ASerialization
 from .contracts import ISerialization
@@ -97,7 +97,7 @@ class XWSerializer(ASerialization):
     # FORMAT DETECTION AND TRANSFORMATION (from XWSerialization)
     # ============================================================================
     
-    def _get_serializer_class(self, format_name: str) -> Type[ISerialization]:
+    def _get_serializer_class(self, format_name: str) -> type[ISerialization]:
         """Get serializer class for format name."""
         module_map = {
             'JSON': ('json', 'JsonSerializer'),
@@ -497,11 +497,11 @@ class XWSerializer(ASerialization):
     # FILE MANAGER INTEGRATION
     # ============================================================================
     
-    def process_file(self, file_path: Union[str, Path], operation: str = 'info') -> Dict[str, Any]:
+    def process_file(self, file_path: Union[str, Path], operation: str = 'info') -> dict[str, Any]:
         """Process file using file manager."""
         return self._file_manager.process_file(file_path, operation)
     
-    def get_file_info(self, file_path: Union[str, Path]) -> Dict[str, Any]:
+    def get_file_info(self, file_path: Union[str, Path]) -> dict[str, Any]:
         """Get comprehensive file information."""
         return self._file_manager.get_file_info(file_path)
     
@@ -734,7 +734,7 @@ class XWSerializer(ASerialization):
     def merge(
         self, 
         file_path: Union[str, Path], 
-        updates: Dict[str, Any], 
+        updates: dict[str, Any], 
         **options
     ) -> None:
         """
@@ -775,13 +775,185 @@ class XWSerializer(ASerialization):
             except Exception as e:
                 logger.error(f"Merge failed for {target_path}: {e}")
                 raise SerializationError(f"Merge failed: {e}") from e
+
+    # ============================================================================
+    # RECORD-LEVEL OPERATIONS (delegated to specialized serializers)
+    # ============================================================================
+
+    def stream_read_record(
+        self,
+        file_path: Union[str, Path],
+        match: callable,
+        projection: Optional[list[Any]] = None,
+        **options: Any,
+    ) -> Any:
+        """
+        Stream-style read of a single logical record.
+
+        Delegates to the specialized serializer when available (e.g. JSONL /
+        NDJSON), falling back to the generic ASerialization implementation
+        which may load the entire file and scan in memory.
+        """
+        target_path = Path(file_path)
+
+        if self.validate_paths:
+            self._path_validator.validate_path(target_path)
+
+        format_hint = self._detect_format_from_path(target_path)
+        specialized = self._ensure_specialized(
+            file_path=target_path,
+            format_hint=format_hint,
+        )
+
+        try:
+            return specialized.stream_read_record(
+                target_path,
+                match,
+                projection=projection,
+                **options,
+            )
+        except NotImplementedError:
+            # Fallback to generic full-load behavior from ASerialization
+            return super().stream_read_record(
+                target_path,
+                match,
+                projection=projection,
+                **options,
+            )
+
+    def stream_update_record(
+        self,
+        file_path: Union[str, Path],
+        match: callable,
+        updater: callable,
+        *,
+        atomic: bool = True,
+        **options: Any,
+    ) -> int:
+        """
+        Stream-style update of logical records.
+
+        Delegates to the specialized serializer when it provides a streaming
+        implementation (e.g. JSONL). Falls back to the generic
+        ASerialization implementation that may load the full file, but still
+        honours atomic save semantics.
+        """
+        target_path = Path(file_path)
+
+        if self.validate_paths:
+            self._path_validator.validate_path(target_path)
+
+        format_hint = self._detect_format_from_path(target_path)
+        specialized = self._ensure_specialized(
+            file_path=target_path,
+            format_hint=format_hint,
+        )
+
+        try:
+            return specialized.stream_update_record(
+                target_path,
+                match,
+                updater,
+                atomic=atomic,
+                **options,
+            )
+        except NotImplementedError:
+            return super().stream_update_record(
+                target_path,
+                match,
+                updater,
+                atomic=atomic,
+                **options,
+            )
+
+    def get_record_page(
+        self,
+        file_path: Union[str, Path],
+        page_number: int,
+        page_size: int,
+        **options: Any,
+    ) -> list[Any]:
+        """
+        Retrieve a logical page of records from a file.
+
+        Delegates to the specialized serializer when supported (for example,
+        JSONL can implement true streaming paging). Falls back to the generic
+        ASerialization implementation, which may load the entire file and
+        slice a top-level list.
+        """
+        target_path = Path(file_path)
+
+        if self.validate_paths:
+            self._path_validator.validate_path(target_path)
+
+        format_hint = self._detect_format_from_path(target_path)
+        specialized = self._ensure_specialized(
+            file_path=target_path,
+            format_hint=format_hint,
+        )
+
+        try:
+            return specialized.get_record_page(
+                target_path,
+                page_number,
+                page_size,
+                **options,
+            )
+        except NotImplementedError:
+            return super().get_record_page(
+                target_path,
+                page_number,
+                page_size,
+                **options,
+            )
+
+    def get_record_by_id(
+        self,
+        file_path: Union[str, Path],
+        id_value: Any,
+        *,
+        id_field: str = "id",
+        **options: Any,
+    ) -> Any:
+        """
+        Retrieve a logical record by identifier.
+
+        Delegates to the specialized serializer where possible; falls back to
+        the generic ASerialization implementation which performs a linear scan
+        over a top-level list.
+        """
+        target_path = Path(file_path)
+
+        if self.validate_paths:
+            self._path_validator.validate_path(target_path)
+
+        format_hint = self._detect_format_from_path(target_path)
+        specialized = self._ensure_specialized(
+            file_path=target_path,
+            format_hint=format_hint,
+        )
+
+        try:
+            return specialized.get_record_by_id(
+                target_path,
+                id_value,
+                id_field=id_field,
+                **options,
+            )
+        except NotImplementedError:
+            return super().get_record_by_id(
+                target_path,
+                id_value,
+                id_field=id_field,
+                **options,
+            )
     
     # ============================================================================
     # BATCH OPERATIONS
     # ============================================================================
     
-    def batch_save(self, data_dict: Dict[Union[str, Path], Any], 
-                   format_hint: Optional[str] = None) -> Dict[str, bool]:
+    def batch_save(self, data_dict: dict[Union[str, Path], Any], 
+                   format_hint: Optional[str] = None) -> dict[str, bool]:
         """Save multiple files in batch."""
         results = {}
         
@@ -796,8 +968,8 @@ class XWSerializer(ASerialization):
         
         return results
     
-    def batch_load(self, file_paths: List[Union[str, Path]], 
-                   format_hint: Optional[str] = None) -> Dict[str, Any]:
+    def batch_load(self, file_paths: list[Union[str, Path]], 
+                   format_hint: Optional[str] = None) -> dict[str, Any]:
         """Load multiple files in batch."""
         results = {}
         
@@ -816,7 +988,7 @@ class XWSerializer(ASerialization):
     # UTILITY METHODS
     # ============================================================================
     
-    def get_serializer_info(self) -> Dict[str, Any]:
+    def get_serializer_info(self) -> dict[str, Any]:
         """Get comprehensive serializer information."""
         return {
             'auto_serialize': self.auto_serialize,
@@ -907,7 +1079,7 @@ class XWSerializer(ASerialization):
         specialized = self._ensure_specialized(data=data)
         return specialized.validate_data(data)
     
-    def get_schema_info(self) -> Dict[str, Any]:
+    def get_schema_info(self) -> dict[str, Any]:
         """Get schema info."""
         if self._specialized_serializer is None:
             return {

exonware/xwsystem/io/serialization/utils/__init__.py

@@ -4,7 +4,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: November 9, 2025
 
 Serialization utilities module.

exonware/xwsystem/io/serialization/utils/path_ops.py

@@ -4,7 +4,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: November 9, 2025
 
 Path operations utilities for serialization formats.
@@ -13,7 +13,7 @@ Provides JSONPointer path parsing and manipulation utilities that serializers
 can use for path-based operations. Includes path validation for security.
 """
 
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 from pathlib import Path
 
 from ...errors import SerializationError
@@ -65,7 +65,7 @@ def validate_json_pointer(path: str) -> bool:
     return True
 
 
-def parse_json_pointer(path: str) -> List[Union[str, int]]:
+def parse_json_pointer(path: str) -> list[Union[str, int]]:
     """
     Parse a JSONPointer path into a list of keys/indices.
     

exonware/xwsystem/io/stream/__init__.py

@@ -4,7 +4,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: 30-Oct-2025
 
 Stream operations and codec-integrated I/O.

exonware/xwsystem/io/stream/async_operations.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
 
 Asynchronous I/O operations for non-blocking file handling.
@@ -15,7 +15,7 @@ import tempfile
 import time
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Any, AsyncContextManager, BinaryIO, List, Optional, TextIO, Union
+from typing import Any, AsyncContextManager, BinaryIO, Optional, TextIO, Union
 
 # Import aiofiles - lazy installation system will handle it if missing
 import aiofiles
@@ -441,7 +441,7 @@ async def async_safe_read_bytes(file_path: Union[str, Path], max_size_mb: float
 async def async_safe_read_with_fallback(
     file_path: Union[str, Path],
     preferred_encoding: str = "utf-8",
-    fallback_encodings: Optional[List[str]] = None,
+    fallback_encodings: Optional[list[str]] = None,
     max_size_mb: float = 100.0,
 ) -> str:
     """

exonware/xwsystem/io/stream/base.py

@@ -4,24 +4,20 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: 30-Oct-2025
 
 Base classes for stream operations.
 """
 
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
 
 from ..contracts import ICodecIO, IPagedCodecIO
 
-T = TypeVar('T')
-R = TypeVar('R')
-
 __all__ = ['ACodecIO', 'APagedCodecIO']
 
 
-class ACodecIO(ICodecIO[T, R], ABC, Generic[T, R]):
+class ACodecIO[T, R](ICodecIO[T, R], ABC):
     """Abstract base for codec I/O operations."""
     
     def __init__(self, codec, source):
@@ -40,7 +36,7 @@ class ACodecIO(ICodecIO[T, R], ABC, Generic[T, R]):
         return self._source
 
 
-class APagedCodecIO(ACodecIO[T, R], IPagedCodecIO[T, R], ABC, Generic[T, R]):
+class APagedCodecIO[T, R](ACodecIO[T, R], IPagedCodecIO[T, R], ABC):
     """Abstract base for paged codec I/O."""
     pass
 

exonware/xwsystem/io/stream/codec_io.py

@@ -4,7 +4,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: 30-Oct-2025
 
 Codec-integrated I/O - THE KILLER FEATURE!
@@ -19,15 +19,12 @@ Priority 5 (Extensibility): Works with ANY codec + ANY data source
 """
 
 from pathlib import Path
-from typing import Generic, TypeVar, Union, Optional, Iterator, Any
+from typing import Union, Optional, Iterator, Any
 
 from ..contracts import ICodecIO, IPagedCodecIO, IDataSource, IPagedDataSource
 
-T = TypeVar('T')  # Model type
-R = TypeVar('R')  # Representation type (bytes or str)
 
-
-class CodecIO(Generic[T, R], ICodecIO[T, R]):
+class CodecIO[T, R](ICodecIO[T, R]):
     """
     I/O operations with integrated codec - THE KILLER FEATURE!
     
@@ -260,7 +257,7 @@ class CodecIO(Generic[T, R], ICodecIO[T, R]):
         return CodecIO(codec, source)
 
 
-class PagedCodecIO(CodecIO[T, R], IPagedCodecIO[T, R]):
+class PagedCodecIO[T, R](CodecIO[T, R], IPagedCodecIO[T, R]):
     """
     CodecIO with paging support - for BIG data files!
     

exonware/xwsystem/ipc/async_fabric.py

@@ -3,7 +3,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: 09-Nov-2025
 
 Async Process Fabric
@@ -27,7 +27,6 @@ from typing import (
     Any,
     AsyncIterator,
     Callable,
-    Dict,
     Iterable,
     Optional,
     Sequence,
@@ -79,9 +78,9 @@ class FabricConfig:
     pool_factory: Callable[..., AsyncProcessPool] = AsyncProcessPool
     queue_factory: Callable[..., AsyncMessageQueue] = AsyncMessageQueue
     shared_memory_factory: Callable[..., SharedMemoryManager] = SharedMemoryManager
-    pool_kwargs: Dict[str, Any] = field(default_factory=dict)
-    queue_kwargs: Dict[str, Any] = field(default_factory=dict)
-    shared_memory_kwargs: Dict[str, Any] = field(default_factory=dict)
+    pool_kwargs: dict[str, Any] = field(default_factory=dict)
+    queue_kwargs: dict[str, Any] = field(default_factory=dict)
+    shared_memory_kwargs: dict[str, Any] = field(default_factory=dict)
 
 
 class AsyncProcessFabric:
@@ -106,9 +105,9 @@ class AsyncProcessFabric:
         pool_factory: Optional[Callable[..., AsyncProcessPool]] = None,
         queue_factory: Optional[Callable[..., AsyncMessageQueue]] = None,
         shared_memory_factory: Optional[Callable[..., SharedMemoryManager]] = None,
-        pool_kwargs: Optional[Dict[str, Any]] = None,
-        queue_kwargs: Optional[Dict[str, Any]] = None,
-        shared_memory_kwargs: Optional[Dict[str, Any]] = None,
+        pool_kwargs: Optional[dict[str, Any]] = None,
+        queue_kwargs: Optional[dict[str, Any]] = None,
+        shared_memory_kwargs: Optional[dict[str, Any]] = None,
         logger_instance: Optional[logging.Logger] = None,
     ) -> None:
         self._config = FabricConfig(

exonware/xwsystem/ipc/base.py

@@ -1,16 +1,16 @@
-#exonware/xsystem/ipc/base.py
+#exonware/xwsystem/ipc/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
 
 IPC module base classes - abstract classes for inter-process communication functionality.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 from .contracts import MessageType, QueueType, ProcessState, SharedMemoryType
 
 
@@ -215,10 +215,10 @@ class AProcessManagerBase(ABC):
     
     def __init__(self):
         """Initialize process manager."""
-        self._processes: Dict[str, Any] = {}
+        self._processes: dict[str, Any] = {}
     
     @abstractmethod
-    def start_process(self, name: str, command: List[str], **kwargs) -> bool:
+    def start_process(self, name: str, command: list[str], **kwargs) -> bool:
         """Start new process."""
         pass
     
@@ -238,7 +238,7 @@ class AProcessManagerBase(ABC):
         pass
     
     @abstractmethod
-    def list_processes(self) -> List[str]:
+    def list_processes(self) -> list[str]:
         """List all managed processes."""
         pass
     
@@ -279,9 +279,9 @@ class AProcessPoolBase(ABC):
             max_processes: Maximum number of processes in pool
         """
         self.max_processes = max_processes
-        self._processes: List[Any] = []
-        self._available_processes: List[Any] = []
-        self._busy_processes: List[Any] = []
+        self._processes: list[Any] = []
+        self._available_processes: list[Any] = []
+        self._busy_processes: list[Any] = []
     
     @abstractmethod
     def initialize(self) -> None:

exonware/xwsystem/ipc/contracts.py

@@ -2,14 +2,14 @@
 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
 
 IPC module contracts - interfaces and enums for inter-process communication.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union, AsyncGenerator, Callable
+from typing import Any, Optional, Union, AsyncGenerator, Callable
 from multiprocessing import Process
 
 # Import enums from types module
@@ -124,7 +124,7 @@ class IProcessManager(ABC):
     """Interface for process management."""
     
     @abstractmethod
-    def create_process(self, target: Callable, args: tuple = (), kwargs: Optional[Dict] = None) -> Process:
+    def create_process(self, target: Callable, args: tuple = (), kwargs: Optional[dict] = None) -> Process:
         """Create new process."""
         pass
     
@@ -163,12 +163,12 @@ class IProcessPool(ABC):
         pass
     
     @abstractmethod
-    def map(self, func: Callable, iterable: List[Any]) -> List[Any]:
+    def map(self, func: Callable, iterable: list[Any]) -> list[Any]:
         """Map function over iterable."""
         pass
     
     @abstractmethod
-    async def map_async(self, func: Callable, iterable: List[Any]) -> List[Any]:
+    async def map_async(self, func: Callable, iterable: list[Any]) -> list[Any]:
         """Map function over iterable asynchronously."""
         pass
     

exonware/xwsystem/ipc/defs.py

@@ -4,7 +4,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.409
+Version: 0.0.1.411
 Generation Date: 07-Sep-2025
 
 IPC types and enums for XWSystem.

exonware/xwsystem/ipc/errors.py

@@ -1,9 +1,9 @@
-#exonware/xsystem/ipc/errors.py
+#exonware/xwsystem/ipc/errors.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
 
 IPC module errors - exception classes for inter-process communication functionality.

exonware/xwsystem/ipc/message_queue.py

@@ -14,7 +14,7 @@ import asyncio
 import queue
 import threading
 import multiprocessing as mp
-from typing import Any, Optional, TypeVar, Generic, Callable
+from typing import Any, Optional, Callable
 from dataclasses import dataclass
 import time
 import logging
@@ -22,11 +22,9 @@ from .defs import MessageQueueType
 
 logger = logging.getLogger(__name__)
 
-T = TypeVar('T')
-
 
 @dataclass
-class Message(Generic[T]):
+class Message[T]:
     """A message in the queue with metadata."""
     data: T
     timestamp: float
@@ -39,7 +37,7 @@ class Message(Generic[T]):
             self.timestamp = time.time()
 
 
-class MessageQueue(Generic[T]):
+class MessageQueue[T]:
     """
     Thread-safe message queue with advanced features.
     
@@ -270,7 +268,7 @@ class MessageQueue(Generic[T]):
         self.shutdown()
 
 
-class AsyncMessageQueue(Generic[T]):
+class AsyncMessageQueue[T]:
     """
     Async-compatible message queue.
     

exonware/xwsystem/ipc/pipes.py

@@ -50,7 +50,7 @@ class Pipe:
         if sys.platform == 'win32':
             # Windows named pipes
             import uuid
-            self.pipe_name = f"\\\\.\\pipe\\xsystem_{uuid.uuid4().hex}"
+            self.pipe_name = f"\\\\.\\pipe\\xwsystem_{uuid.uuid4().hex}"
             self._create_windows_pipe()
         else:
             # Unix domain sockets or os.pipe()
@@ -251,7 +251,7 @@ class AsyncPipe:
         
         # Create temporary socket path
         temp_dir = tempfile.gettempdir()
-        self._pipe_path = os.path.join(temp_dir, f"xsystem_pipe_{os.getpid()}")
+        self._pipe_path = os.path.join(temp_dir, f"xwsystem_pipe_{os.getpid()}")
         
         # Remove existing socket file
         try: