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

exonware/xwsystem/io/contracts.py

@@ -1,15 +1,18 @@
+#exonware/xwsystem/src/exonware/xwsystem/io/contracts.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
 
 IO module contracts - interfaces and enums for input/output operations.
 """
 
-from abc import ABC, abstractmethod
-from typing import Any, Optional, Union, AsyncGenerator, BinaryIO, TextIO, Protocol, runtime_checkable, Callable, Iterator
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+from typing import Any, Optional, AsyncGenerator, BinaryIO, TextIO, Protocol, runtime_checkable, Callable, Iterator
 from typing_extensions import TypeAlias
 from pathlib import Path
 
@@ -36,7 +39,8 @@ from .defs import (
 # FILE INTERFACES
 # ============================================================================
 
-class IFile(ABC):
+@runtime_checkable
+class IFile(Protocol):
     """
     Interface for file operations with both static and instance methods.
     
@@ -51,234 +55,198 @@ class IFile(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
     def open(self, mode: FileMode = FileMode.READ) -> None:
         """Open file with specified mode."""
-        pass
+        ...
     
-    @abstractmethod
-    def read(self, size: Optional[int] = None) -> Union[str, bytes]:
+    def read(self, size: Optional[int] = None) -> str | bytes:
         """Read from file."""
-        pass
+        ...
     
-    @abstractmethod
-    def write(self, data: Union[str, bytes]) -> int:
+    def write(self, data: str | bytes) -> int:
         """Write to file."""
-        pass
+        ...
     
-    @abstractmethod
     def close(self) -> None:
         """Close file."""
-        pass
+        ...
     
-    @abstractmethod
     def save(self, data: Any, **kwargs) -> bool:
         """Save data to file."""
-        pass
+        ...
     
-    @abstractmethod
     def load(self, **kwargs) -> Any:
         """Load data from file."""
-        pass
+        ...
     
-    @abstractmethod
-    def save_as(self, path: Union[str, Path], data: Any, **kwargs) -> bool:
+    def save_as(self, path: str | Path, data: Any, **kwargs) -> bool:
         """Save data to specific path."""
-        pass
+        ...
     
-    @abstractmethod
-    def to_file(self, path: Union[str, Path], **kwargs) -> bool:
+    def to_file(self, path: str | Path, **kwargs) -> bool:
         """Write current object to file."""
-        pass
+        ...
     
-    @abstractmethod
-    def from_file(self, path: Union[str, Path], **kwargs) -> 'IFile':
+    def from_file(self, path: str | Path, **kwargs) -> IFile:
         """Load object from file."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def exists(path: Union[str, Path]) -> bool:
+    def exists(path: str | Path) -> bool:
         """Check if file exists."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def size(path: Union[str, Path]) -> int:
+    def size(path: str | Path) -> int:
         """Get file size."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def delete(path: Union[str, Path]) -> bool:
+    def delete(path: str | Path) -> bool:
         """Delete file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def copy(source: Union[str, Path], destination: Union[str, Path]) -> bool:
+    def copy(source: str | Path, destination: str | Path) -> bool:
         """Copy file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def move(source: Union[str, Path], destination: Union[str, Path]) -> bool:
+    def move(source: str | Path, destination: str | Path) -> bool:
         """Move file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def rename(old_path: Union[str, Path], new_path: Union[str, Path]) -> bool:
+    def rename(old_path: str | Path, new_path: str | Path) -> bool:
         """Rename file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_modified_time(path: Union[str, Path]) -> float:
+    def get_modified_time(path: str | Path) -> float:
         """Get file modification time."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_created_time(path: Union[str, Path]) -> float:
+    def get_created_time(path: str | Path) -> float:
         """Get file creation time."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_permissions(path: Union[str, Path]) -> int:
+    def get_permissions(path: str | Path) -> int:
         """Get file permissions."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_readable(path: Union[str, Path]) -> bool:
+    def is_readable(path: str | Path) -> bool:
         """Check if file is readable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_writable(path: Union[str, Path]) -> bool:
+    def is_writable(path: str | Path) -> bool:
         """Check if file is writable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_executable(path: Union[str, Path]) -> bool:
+    def is_executable(path: str | Path) -> bool:
         """Check if file is executable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def read_text(path: Union[str, Path], encoding: str = 'utf-8') -> str:
+    def read_text(path: str | Path, encoding: str = 'utf-8') -> str:
         """Read file as text."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def read_bytes(path: Union[str, Path]) -> bytes:
+    def read_bytes(path: str | Path) -> bytes:
         """Read file as bytes."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def write_text(path: Union[str, Path], content: str, encoding: str = 'utf-8') -> bool:
+    def write_text(path: str | Path, content: str, encoding: str = 'utf-8') -> bool:
         """Write text to file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def write_bytes(path: Union[str, Path], content: bytes) -> bool:
+    def write_bytes(path: str | Path, content: bytes) -> bool:
         """Write bytes to file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def safe_read_text(path: Union[str, Path], encoding: str = 'utf-8') -> Optional[str]:
+    def safe_read_text(path: str | Path, encoding: str = 'utf-8') -> Optional[str]:
         """Safely read text file, returning None on error."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def safe_read_bytes(path: Union[str, Path]) -> Optional[bytes]:
+    def safe_read_bytes(path: str | Path) -> Optional[bytes]:
         """Safely read binary file, returning None on error."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def safe_write_text(path: Union[str, Path], content: str, encoding: str = 'utf-8') -> bool:
+    def safe_write_text(path: str | Path, content: str, encoding: str = 'utf-8') -> bool:
         """Safely write text to file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def safe_write_bytes(path: Union[str, Path], content: bytes) -> bool:
+    def safe_write_bytes(path: str | Path, content: bytes) -> bool:
         """Safely write bytes to file."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC UTILITY METHODS (File Manager Features)
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def atomic_write(file_path: Union[str, Path], data: Union[str, bytes], 
+    def atomic_write(file_path: str | Path, data: str | bytes, 
                     backup: bool = True) -> OperationResult:
         """Atomically write data to file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_copy(source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_copy(source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically copy file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_move(source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_move(source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically move file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_delete(file_path: Union[str, Path], backup: bool = True) -> OperationResult:
+    def atomic_delete(file_path: str | Path, backup: bool = True) -> OperationResult:
         """Atomically delete file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def create_backup(source: Union[str, Path], backup_dir: Union[str, Path]) -> Optional[Path]:
+    def create_backup(source: str | Path, backup_dir: str | Path) -> Optional[Path]:
         """Create backup of file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def restore_backup(backup_path: Union[str, Path], target: Union[str, Path]) -> OperationResult:
+    def restore_backup(backup_path: str | Path, target: str | Path) -> OperationResult:
         """Restore from backup (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
     def create_temp_file(suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary file (static version)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
     def create_temp_directory(suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary directory (static version)."""
-        pass
+        ...
 
 
 # ============================================================================
 # FOLDER INTERFACES
 # ============================================================================
 
-class IFolder(ABC):
+@runtime_checkable
+class IFolder(Protocol):
     """
     Interface for folder/directory operations with both static and instance methods.
     
@@ -293,145 +261,123 @@ class IFolder(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
     def create(self, parents: bool = True, exist_ok: bool = True) -> bool:
         """Create directory."""
-        pass
+        ...
     
-    @abstractmethod
     def delete(self, recursive: bool = False) -> bool:
         """Delete directory."""
-        pass
+        ...
     
-    @abstractmethod
     def list_files(self, pattern: Optional[str] = None, recursive: bool = False) -> list[Path]:
         """List files in directory."""
-        pass
+        ...
     
-    @abstractmethod
     def list_directories(self, recursive: bool = False) -> list[Path]:
         """List subdirectories."""
-        pass
+        ...
     
-    @abstractmethod
     def walk(self) -> list[tuple[Path, list[str], list[str]]]:
         """Walk directory tree."""
-        pass
+        ...
     
-    @abstractmethod
     def get_size(self) -> int:
         """Get directory size."""
-        pass
+        ...
     
-    @abstractmethod
     def is_empty(self) -> bool:
         """Check if directory is empty."""
-        pass
+        ...
     
-    @abstractmethod
-    def copy_to(self, destination: Union[str, Path]) -> bool:
+    def copy_to(self, destination: str | Path) -> bool:
         """Copy directory to destination."""
-        pass
+        ...
     
-    @abstractmethod
-    def move_to(self, destination: Union[str, Path]) -> bool:
+    def move_to(self, destination: str | Path) -> bool:
         """Move directory to destination."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def exists(path: Union[str, Path]) -> bool:
+    def exists(path: str | Path) -> bool:
         """Check if directory exists."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def create_dir(path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> bool:
+    def create_dir(path: str | Path, parents: bool = True, exist_ok: bool = True) -> bool:
         """Create directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def delete_dir(path: Union[str, Path], recursive: bool = False) -> bool:
+    def delete_dir(path: str | Path, recursive: bool = False) -> bool:
         """Delete directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def list_files_static(path: Union[str, Path], pattern: Optional[str] = None, recursive: bool = False) -> list[Path]:
+    def list_files_static(path: str | Path, pattern: Optional[str] = None, recursive: bool = False) -> list[Path]:
         """List files in directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def list_directories_static(path: Union[str, Path], recursive: bool = False) -> list[Path]:
+    def list_directories_static(path: str | Path, recursive: bool = False) -> list[Path]:
         """List subdirectories."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def walk_static(path: Union[str, Path]) -> list[tuple[Path, list[str], list[str]]]:
+    def walk_static(path: str | Path) -> list[tuple[Path, list[str], list[str]]]:
         """Walk directory tree."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_size_static(path: Union[str, Path]) -> int:
+    def get_size_static(path: str | Path) -> int:
         """Get directory size."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_empty_static(path: Union[str, Path]) -> bool:
+    def is_empty_static(path: str | Path) -> bool:
         """Check if directory is empty."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def copy_dir(source: Union[str, Path], destination: Union[str, Path]) -> bool:
+    def copy_dir(source: str | Path, destination: str | Path) -> bool:
         """Copy directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def move_dir(source: Union[str, Path], destination: Union[str, Path]) -> bool:
+    def move_dir(source: str | Path, destination: str | Path) -> bool:
         """Move directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_permissions(path: Union[str, Path]) -> int:
+    def get_permissions(path: str | Path) -> int:
         """Get directory permissions."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_readable(path: Union[str, Path]) -> bool:
+    def is_readable(path: str | Path) -> bool:
         """Check if directory is readable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_writable(path: Union[str, Path]) -> bool:
+    def is_writable(path: str | Path) -> bool:
         """Check if directory is writable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_executable(path: Union[str, Path]) -> bool:
+    def is_executable(path: str | Path) -> bool:
         """Check if directory is executable."""
-        pass
+        ...
 
 
 # ============================================================================
 # PATH INTERFACES
 # ============================================================================
 
-class IPath(ABC):
+@runtime_checkable
+class IPath(Protocol):
     """
     Interface for path operations with both static and instance methods.
     
@@ -446,107 +392,92 @@ class IPath(ABC):
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def normalize(path: Union[str, Path]) -> Path:
+    def normalize(path: str | Path) -> Path:
         """Normalize path."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def resolve(path: Union[str, Path]) -> Path:
+    def resolve(path: str | Path) -> Path:
         """Resolve path."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def absolute(path: Union[str, Path]) -> Path:
+    def absolute(path: str | Path) -> Path:
         """Get absolute path."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def relative(path: Union[str, Path], start: Optional[Union[str, Path]] = None) -> Path:
+    def relative(path: str | Path, start: Optional[str | Path] = None) -> Path:
         """Get relative path."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def join(*paths: Union[str, Path]) -> Path:
+    def join(*paths: str | Path) -> Path:
         """Join paths."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def split(path: Union[str, Path]) -> tuple[Path, str]:
+    def split(path: str | Path) -> tuple[Path, str]:
         """Split path into directory and filename."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_extension(path: Union[str, Path]) -> str:
+    def get_extension(path: str | Path) -> str:
         """Get file extension."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_stem(path: Union[str, Path]) -> str:
+    def get_stem(path: str | Path) -> str:
         """Get file stem (name without extension)."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_name(path: Union[str, Path]) -> str:
+    def get_name(path: str | Path) -> str:
         """Get file/directory name."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_parent(path: Union[str, Path]) -> Path:
+    def get_parent(path: str | Path) -> Path:
         """Get parent directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_absolute(path: Union[str, Path]) -> bool:
+    def is_absolute(path: str | Path) -> bool:
         """Check if path is absolute."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_relative(path: Union[str, Path]) -> bool:
+    def is_relative(path: str | Path) -> bool:
         """Check if path is relative."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def get_parts(path: Union[str, Path]) -> tuple:
+    def get_parts(path: str | Path) -> tuple:
         """Get path parts."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def match(path: Union[str, Path], pattern: str) -> bool:
+    def match(path: str | Path, pattern: str) -> bool:
         """Check if path matches pattern."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def with_suffix(path: Union[str, Path], suffix: str) -> Path:
+    def with_suffix(path: str | Path, suffix: str) -> Path:
         """Get path with new suffix."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def with_name(path: Union[str, Path], name: str) -> Path:
+    def with_name(path: str | Path, name: str) -> Path:
         """Get path with new name."""
-        pass
+        ...
 
 
 # ============================================================================
 # STREAM INTERFACES
 # ============================================================================
 
-class IStream(ABC):
+@runtime_checkable
+class IStream(Protocol):
     """
     Interface for stream operations with both static and instance methods.
     
@@ -560,76 +491,66 @@ class IStream(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
-    def read(self, size: Optional[int] = None) -> Union[str, bytes]:
+    def read(self, size: Optional[int] = None) -> str | bytes:
         """Read from stream."""
-        pass
+        ...
     
-    @abstractmethod
-    def write(self, data: Union[str, bytes]) -> int:
+    def write(self, data: str | bytes) -> int:
         """Write to stream."""
-        pass
+        ...
     
-    @abstractmethod
     def seek(self, position: int, whence: int = 0) -> int:
         """Seek stream position."""
-        pass
+        ...
     
-    @abstractmethod
     def tell(self) -> int:
         """Get current stream position."""
-        pass
+        ...
     
-    @abstractmethod
     def flush(self) -> None:
         """Flush stream buffer."""
-        pass
+        ...
     
-    @abstractmethod
     def close(self) -> None:
         """Close stream."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def open_file(path: Union[str, Path], mode: str = 'r', encoding: Optional[str] = None) -> Union[TextIO, BinaryIO]:
+    def open_file(path: str | Path, mode: str = 'r', encoding: Optional[str] = None) -> TextIO | BinaryIO:
         """Open file as stream."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_closed(stream: Union[TextIO, BinaryIO]) -> bool:
+    def is_closed(stream: TextIO | BinaryIO) -> bool:
         """Check if stream is closed."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def readable(stream: Union[TextIO, BinaryIO]) -> bool:
+    def readable(stream: TextIO | BinaryIO) -> bool:
         """Check if stream is readable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def writable(stream: Union[TextIO, BinaryIO]) -> bool:
+    def writable(stream: TextIO | BinaryIO) -> bool:
         """Check if stream is writable."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def seekable(stream: Union[TextIO, BinaryIO]) -> bool:
+    def seekable(stream: TextIO | BinaryIO) -> bool:
         """Check if stream is seekable."""
-        pass
+        ...
 
 
 # ============================================================================
 # ASYNC I/O INTERFACES
 # ============================================================================
 
-class IAsyncIO(ABC):
+@runtime_checkable
+class IAsyncIO(Protocol):
     """
     Interface for async I/O operations with both static and instance methods.
     
@@ -643,76 +564,66 @@ class IAsyncIO(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
-    async def aread(self, size: Optional[int] = None) -> Union[str, bytes]:
+    async def aread(self, size: Optional[int] = None) -> str | bytes:
         """Async read operation."""
-        pass
+        ...
     
-    @abstractmethod
-    async def awrite(self, data: Union[str, bytes]) -> int:
+    async def awrite(self, data: str | bytes) -> int:
         """Async write operation."""
-        pass
+        ...
     
-    @abstractmethod
     async def aseek(self, position: int, whence: int = 0) -> int:
         """Async seek operation."""
-        pass
+        ...
     
-    @abstractmethod
     async def atell(self) -> int:
         """Async tell operation."""
-        pass
+        ...
     
-    @abstractmethod
     async def aflush(self) -> None:
         """Async flush operation."""
-        pass
+        ...
     
-    @abstractmethod
     async def aclose(self) -> None:
         """Async close operation."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    async def aopen_file(path: Union[str, Path], mode: str = 'r', encoding: Optional[str] = None) -> Any:
+    async def aopen_file(path: str | Path, mode: str = 'r', encoding: Optional[str] = None) -> Any:
         """Async open file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    async def aread_text(path: Union[str, Path], encoding: str = 'utf-8') -> str:
+    async def aread_text(path: str | Path, encoding: str = 'utf-8') -> str:
         """Async read text file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    async def aread_bytes(path: Union[str, Path]) -> bytes:
+    async def aread_bytes(path: str | Path) -> bytes:
         """Async read binary file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    async def awrite_text(path: Union[str, Path], content: str, encoding: str = 'utf-8') -> bool:
+    async def awrite_text(path: str | Path, content: str, encoding: str = 'utf-8') -> bool:
         """Async write text to file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    async def awrite_bytes(path: Union[str, Path], content: bytes) -> bool:
+    async def awrite_bytes(path: str | Path, content: bytes) -> bool:
         """Async write bytes to file."""
-        pass
+        ...
 
 
 # ============================================================================
 # ATOMIC OPERATIONS INTERFACES
 # ============================================================================
 
-class IAtomicOperations(ABC):
+@runtime_checkable
+class IAtomicOperations(Protocol):
     """
     Interface for atomic operations with both static and instance methods.
     
@@ -726,73 +637,64 @@ class IAtomicOperations(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
-    def atomic_write(self, file_path: Union[str, Path], data: Union[str, bytes], 
+    def atomic_write(self, file_path: str | Path, data: str | bytes, 
                     backup: bool = True) -> OperationResult:
         """Atomically write data to file."""
-        pass
+        ...
     
-    @abstractmethod
-    def atomic_copy(self, source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_copy(self, source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically copy file."""
-        pass
+        ...
     
-    @abstractmethod
-    def atomic_move(self, source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_move(self, source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically move file."""
-        pass
+        ...
     
-    @abstractmethod
-    def atomic_delete(self, file_path: Union[str, Path], backup: bool = True) -> OperationResult:
+    def atomic_delete(self, file_path: str | Path, backup: bool = True) -> OperationResult:
         """Atomically delete file."""
-        pass
+        ...
     
-    @abstractmethod
-    def atomic_rename(self, old_path: Union[str, Path], new_path: Union[str, Path]) -> OperationResult:
+    def atomic_rename(self, old_path: str | Path, new_path: str | Path) -> OperationResult:
         """Atomically rename file."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def atomic_write_static(file_path: Union[str, Path], data: Union[str, bytes], 
+    def atomic_write_static(file_path: str | Path, data: str | bytes, 
                            backup: bool = True) -> OperationResult:
         """Atomically write data to file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_copy_static(source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_copy_static(source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically copy file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_move_static(source: Union[str, Path], destination: Union[str, Path]) -> OperationResult:
+    def atomic_move_static(source: str | Path, destination: str | Path) -> OperationResult:
         """Atomically move file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_delete_static(file_path: Union[str, Path], backup: bool = True) -> OperationResult:
+    def atomic_delete_static(file_path: str | Path, backup: bool = True) -> OperationResult:
         """Atomically delete file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def atomic_rename_static(old_path: Union[str, Path], new_path: Union[str, Path]) -> OperationResult:
+    def atomic_rename_static(old_path: str | Path, new_path: str | Path) -> OperationResult:
         """Atomically rename file."""
-        pass
+        ...
 
 
 # ============================================================================
 # BACKUP OPERATIONS INTERFACES
 # ============================================================================
 
-class IBackupOperations(ABC):
+@runtime_checkable
+class IBackupOperations(Protocol):
     """
     Interface for backup operations with both static and instance methods.
     
@@ -806,71 +708,62 @@ class IBackupOperations(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
-    def create_backup(self, source: Union[str, Path], backup_dir: Union[str, Path]) -> Optional[Path]:
+    def create_backup(self, source: str | Path, backup_dir: str | Path) -> Optional[Path]:
         """Create backup of file or directory."""
-        pass
+        ...
     
-    @abstractmethod
-    def restore_backup(self, backup_path: Union[str, Path], target: Union[str, Path]) -> OperationResult:
+    def restore_backup(self, backup_path: str | Path, target: str | Path) -> OperationResult:
         """Restore from backup."""
-        pass
+        ...
     
-    @abstractmethod
-    def list_backups(self, backup_dir: Union[str, Path]) -> list[Path]:
+    def list_backups(self, backup_dir: str | Path) -> list[Path]:
         """List available backups."""
-        pass
+        ...
     
-    @abstractmethod
-    def cleanup_backups(self, backup_dir: Union[str, Path], max_age_days: int = 30) -> int:
+    def cleanup_backups(self, backup_dir: str | Path, max_age_days: int = 30) -> int:
         """Cleanup old backups."""
-        pass
+        ...
     
-    @abstractmethod
-    def verify_backup(self, backup_path: Union[str, Path]) -> bool:
+    def verify_backup(self, backup_path: str | Path) -> bool:
         """Verify backup integrity."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
-    def create_backup_static(source: Union[str, Path], backup_dir: Union[str, Path]) -> Optional[Path]:
+    def create_backup_static(source: str | Path, backup_dir: str | Path) -> Optional[Path]:
         """Create backup of file or directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def restore_backup_static(backup_path: Union[str, Path], target: Union[str, Path]) -> OperationResult:
+    def restore_backup_static(backup_path: str | Path, target: str | Path) -> OperationResult:
         """Restore from backup."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def list_backups_static(backup_dir: Union[str, Path]) -> list[Path]:
+    def list_backups_static(backup_dir: str | Path) -> list[Path]:
         """List available backups."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def cleanup_backups_static(backup_dir: Union[str, Path], max_age_days: int = 30) -> int:
+    def cleanup_backups_static(backup_dir: str | Path, max_age_days: int = 30) -> int:
         """Cleanup old backups."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def verify_backup_static(backup_path: Union[str, Path]) -> bool:
+    def verify_backup_static(backup_path: str | Path) -> bool:
         """Verify backup integrity."""
-        pass
+        ...
 
 
 # ============================================================================
 # TEMPORARY OPERATIONS INTERFACES
 # ============================================================================
 
-class ITemporaryOperations(ABC):
+@runtime_checkable
+class ITemporaryOperations(Protocol):
     """
     Interface for temporary operations with both static and instance methods.
     
@@ -884,59 +777,50 @@ class ITemporaryOperations(ABC):
     # INSTANCE METHODS
     # ============================================================================
     
-    @abstractmethod
     def create_temp_file(self, suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary file."""
-        pass
+        ...
     
-    @abstractmethod
     def create_temp_directory(self, suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary directory."""
-        pass
+        ...
     
-    @abstractmethod
-    def cleanup_temp(self, path: Union[str, Path]) -> bool:
+    def cleanup_temp(self, path: str | Path) -> bool:
         """Cleanup temporary file or directory."""
-        pass
+        ...
     
-    @abstractmethod
     def cleanup_all_temp(self) -> int:
         """Cleanup all temporary files and directories."""
-        pass
+        ...
     
     # ============================================================================
     # STATIC METHODS
     # ============================================================================
     
     @staticmethod
-    @abstractmethod
     def create_temp_file_static(suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary file."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
     def create_temp_directory_static(suffix: Optional[str] = None, prefix: Optional[str] = None) -> Path:
         """Create temporary directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def cleanup_temp_static(path: Union[str, Path]) -> bool:
+    def cleanup_temp_static(path: str | Path) -> bool:
         """Cleanup temporary file or directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
     def get_temp_base_dir() -> Path:
         """Get temporary base directory."""
-        pass
+        ...
     
     @staticmethod
-    @abstractmethod
-    def is_temp(path: Union[str, Path]) -> bool:
+    def is_temp(path: str | Path) -> bool:
         """Check if path is temporary."""
-        pass
+        ...
 
 
 # ============================================================================
@@ -963,7 +847,7 @@ class IUnifiedIO(IFile, IFolder, IPath, IStream, IAsyncIO, IAtomicOperations, IB
     
     This interface follows the xwsystem pattern of combining existing interfaces
     rather than creating new abstractions, maximizing code reuse and maintaining
-    backward compatibility.
+    code reuse.
     """
     pass
 
@@ -1001,110 +885,103 @@ class IFileManager(IFile, IFolder, IPath, IAtomicOperations, IBackupOperations,
 # DATA SOURCE INTERFACES (Used by file/, stream/)
 # ============================================================================
 
-class IDataSource[T](ABC):
+@runtime_checkable
+class IDataSource[T](Protocol):
     """Universal data source interface for various data sources."""
     
-    @abstractmethod
     def read(self) -> T:
         """Read data from source."""
-        pass
+        ...
     
-    @abstractmethod
     def write(self, data: T) -> None:
         """Write data to source."""
-        pass
+        ...
 
 
-class IPagedDataSource[T](ABC):
+@runtime_checkable
+class IPagedDataSource[T](Protocol):
     """Paged data source interface for large data sets."""
     
-    @abstractmethod
     def read_page(self, page_number: int) -> list[T]:
         """Read a specific page of data."""
-        pass
+        ...
     
-    @abstractmethod
     def get_page_count(self) -> int:
         """Get total number of pages."""
-        pass
+        ...
 
 
 # ============================================================================
 # CODEC-INTEGRATED IO INTERFACES (Used by stream/)
 # ============================================================================
 
-class ICodecIO[T, R](ABC):
+@runtime_checkable
+class ICodecIO[T, R](Protocol):
     """Codec-integrated IO interface with source type T and result type R."""
     
-    @abstractmethod
     def read_as(self, codec: str):
         """Read and decode data using specified codec."""
-        pass
+        ...
     
-    @abstractmethod
     def write_as(self, data, codec: str) -> None:
         """Encode and write data using specified codec."""
-        pass
+        ...
 
 
-class IPagedCodecIO[T, R](ABC):
+@runtime_checkable
+class IPagedCodecIO[T, R](Protocol):
     """Paged codec-integrated IO interface with source type T and result type R."""
     
-    @abstractmethod
     def read_page_as(self, page_number: int, codec: str):
         """Read and decode a page using specified codec."""
-        pass
+        ...
 
 
 # ============================================================================
 # FILE SYSTEM INTERFACES (Used by common/, filesystem/)
 # ============================================================================
 
-class IFileWatcher(ABC):
+@runtime_checkable
+class IFileWatcher(Protocol):
     """Interface for watching file system changes."""
     
-    @abstractmethod
-    def watch(self, path: Union[str, Path]) -> None:
+    def watch(self, path: str | Path) -> None:
         """Start watching a path."""
-        pass
+        ...
     
-    @abstractmethod
     def stop(self) -> None:
         """Stop watching."""
-        pass
+        ...
 
 
-class IFileLock(ABC):
+@runtime_checkable
+class IFileLock(Protocol):
     """Interface for file locking."""
     
-    @abstractmethod
     def acquire(self) -> bool:
         """Acquire the lock."""
-        pass
+        ...
     
-    @abstractmethod
     def release(self) -> None:
         """Release the lock."""
-        pass
+        ...
 
 
-class IFileSystem(ABC):
+@runtime_checkable
+class IFileSystem(Protocol):
     """Virtual file system interface."""
     
-    @abstractmethod
     def read(self, path: str) -> bytes:
         """Read file contents."""
-        pass
+        ...
     
-    @abstractmethod
     def write(self, path: str, data: bytes) -> None:
         """Write file contents."""
-        pass
+        ...
     
-    @abstractmethod
     def exists(self, path: str) -> bool:
         """Check if path exists."""
-        pass
+        ...
 
 
 # ============================================================================
@@ -1393,7 +1270,7 @@ class IAtomicWriter(Protocol):
         """Write data atomically."""
         ...
     
-    def __enter__(self) -> 'IAtomicWriter':
+    def __enter__(self) -> IAtomicWriter:
         """Enter context manager."""
         ...
     
@@ -1423,23 +1300,21 @@ class IArchiver[T](ICodec[T, bytes]):
     NOT limited to file paths - works on data in RAM!
     """
     
-    @abstractmethod
     def compress(self, data: T, **options) -> bytes:
         """
         Compress data to archive bytes (in RAM).
         
         Delegates to encode() internally.
         """
-        pass
+        ...
     
-    @abstractmethod
     def extract(self, archive_bytes: bytes, **options) -> T:
         """
         Extract archive bytes to data (in RAM).
         
         Delegates to decode() internally.
         """
-        pass
+        ...
 
 
 class IArchiveFile(IFile):
@@ -1455,28 +1330,25 @@ class IArchiveFile(IFile):
     - Archive file management
     """
     
-    @abstractmethod
     def add_files(self, files: list[Path], **options) -> None:
         """Add files to archive (uses archiver.compress internally)."""
-        pass
+        ...
     
-    @abstractmethod
     def extract_to(self, dest: Path, **options) -> list[Path]:
         """Extract archive to destination (uses archiver.extract internally)."""
-        pass
+        ...
     
-    @abstractmethod
     def list_contents(self) -> list[str]:
         """List files in archive."""
-        pass
+        ...
     
-    @abstractmethod
     def get_archiver(self) -> IArchiver:
         """Get the underlying archiver codec."""
-        pass
+        ...
 
 
-class ICompression(ABC):
+@runtime_checkable
+class ICompression(Protocol):
     """
     Interface for raw compression operations (gzip, bz2, lzma, etc.).
     
@@ -1484,30 +1356,28 @@ class ICompression(ABC):
     Separate from IArchiver which handles archive formats.
     """
     
-    @abstractmethod
     def compress(self, data: bytes, **options) -> bytes:
         """Compress raw bytes."""
-        pass
+        ...
     
-    @abstractmethod
     def decompress(self, data: bytes, **options) -> bytes:
         """Decompress raw bytes."""
-        pass
+        ...
 
 
 @runtime_checkable
 class IPathValidator(Protocol):
     """Interface for path validation and security checks."""
     
-    def validate_path(self, path: Union[str, Path]) -> bool:
+    def validate_path(self, path: str | Path) -> bool:
         """Validate path safety."""
         ...
     
-    def is_safe_path(self, path: Union[str, Path]) -> bool:
+    def is_safe_path(self, path: str | Path) -> bool:
         """Check if path is safe to use."""
         ...
     
-    def normalize_path(self, path: Union[str, Path]) -> Path:
+    def normalize_path(self, path: str | Path) -> Path:
         """Normalize and resolve path."""
         ...
 
@@ -1529,11 +1399,11 @@ class IFileSource(Protocol):
         """URI scheme."""
         ...
     
-    def read(self, **options) -> Union[bytes, str]:
+    def read(self, **options) -> bytes | str:
         """Read entire file content."""
         ...
     
-    def write(self, data: Union[bytes, str], **options) -> None:
+    def write(self, data: bytes | str, **options) -> None:
         """Write entire content to file."""
         ...
     
@@ -1554,19 +1424,19 @@ class IPagedSource(Protocol):
         """Total file size in bytes."""
         ...
     
-    def read_page(self, page: int, page_size: int, **options) -> Union[bytes, str]:
+    def read_page(self, page: int, page_size: int, **options) -> bytes | str:
         """Read specific page."""
         ...
     
-    def read_chunk(self, offset: int, size: int, **options) -> Union[bytes, str]:
+    def read_chunk(self, offset: int, size: int, **options) -> bytes | str:
         """Read chunk by byte offset."""
         ...
     
-    def iter_pages(self, page_size: int, **options) -> Iterator[Union[bytes, str]]:
+    def iter_pages(self, page_size: int, **options) -> Iterator[bytes | str]:
         """Iterate over pages."""
         ...
     
-    def iter_chunks(self, chunk_size: int, **options) -> Iterator[Union[bytes, str]]:
+    def iter_chunks(self, chunk_size: int, **options) -> Iterator[bytes | str]:
         """Iterate over chunks."""
         ...
 
@@ -1595,7 +1465,7 @@ class IPagingStrategy(Protocol):
         mode: str = 'rb',
         encoding: Optional[str] = None,
         **options
-    ) -> Union[bytes, str]:
+    ) -> bytes | str:
         """
         Read specific page using this strategy.
         
@@ -1619,7 +1489,7 @@ class IPagingStrategy(Protocol):
         mode: str = 'rb',
         encoding: Optional[str] = None,
         **options
-    ) -> Iterator[Union[bytes, str]]:
+    ) -> Iterator[bytes | str]:
         """
         Iterate over pages using this strategy.
         
@@ -1698,12 +1568,10 @@ class IPagedCodecIO[T, R](ICodecIO[T, R]):
     Interface for paged codec I/O.
     """
     
-    @abstractmethod
     def iter_items(self, page_size: int, **opts):
         """Iterate over decoded items."""
         ...
     
-    @abstractmethod
     def load_page(self, page: int, page_size: int, **opts) -> list[T]:
         """Load specific page."""
         ...