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

exonware/xwsystem/config/contracts.py

@@ -3,7 +3,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 Configuration protocol interfaces for XWSystem.

exonware/xwsystem/config/defaults.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 Default configuration constants for XSystem framework.

exonware/xwsystem/config/defs.py

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

exonware/xwsystem/config/errors.py

@@ -1,9 +1,9 @@
-#exonware/xsystem/config/errors.py
+#exonware/xwsystem/config/errors.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 Configuration module errors - exception classes for configuration functionality.

exonware/xwsystem/config/logging.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 Logging configuration for XSystem.

exonware/xwsystem/config/logging_setup.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 05, 2025
 
 Logging configuration setup for XSystem.
@@ -19,7 +19,7 @@ from .defaults import LOGGING_ENABLED, LOGGING_LEVEL
 
 
 def setup_logging(
-    log_file="logs/xsystem.log",
+    log_file="logs/xwsystem.log",
     level=logging.INFO,
     max_bytes=10 * 1024 * 1024,
     backup_count=5,

exonware/xwsystem/config/performance.py

@@ -1,406 +1,133 @@
-"""
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.410
-Generation Date: September 04, 2025
-
-Performance Configuration Management
+"""Performance optimization configuration for xwsystem I/O operations.
 
-Centralized configuration for XSystem performance limits, timeouts, and optimization settings.
+This module provides configuration options to enable/disable performance
+optimizations (parallel index building, append-only logs) with automatic
+fallback to original implementations.
 """
 
-from typing import Any, Final, Optional
-from dataclasses import dataclass, field
-import os
-from pathlib import Path
-
-from ..config.logging_setup import get_logger
-
-logger = get_logger(__name__)
-
-
-@dataclass
-class SerializationLimits:
-    """Configuration limits for serialization operations."""
-    
-    # Data size limits
-    max_size_mb: float = 50.0                    # Maximum data size in MB
-    max_depth: int = 100                         # Maximum nesting depth
-    max_string_length: int = 1_000_000          # Maximum string length
-    max_list_items: int = 100_000               # Maximum list/array items
-    max_dict_keys: int = 10_000                 # Maximum dictionary keys
-    
-    # File operation limits
-    max_file_size_mb: float = 100.0             # Maximum file size for operations
-    max_path_length: int = 4096                 # Maximum file path length
-    
-    # Performance settings
-    use_atomic_writes: bool = True              # Use atomic file operations by default
-    validate_input: bool = True                 # Enable input validation by default
-    validate_paths: bool = True                 # Enable path validation by default
-    
-    # Memory management
-    max_memory_mb: float = 200.0                # Maximum memory usage for operations
-    enable_compression: bool = False            # Enable compression by default
-
-
-@dataclass
-class NetworkLimits:
-    """Configuration limits for network operations."""
-    
-    # Timeout settings (seconds)
-    connect_timeout: float = 30.0               # Connection timeout
-    read_timeout: float = 60.0                  # Read timeout
-    total_timeout: float = 300.0                # Total request timeout
-    
-    # Retry settings
-    max_retries: int = 3                        # Maximum retry attempts
-    retry_backoff_factor: float = 2.0           # Exponential backoff factor
-    retry_max_delay: float = 60.0               # Maximum retry delay
-    
-    # Size limits
-    max_response_size_mb: float = 100.0         # Maximum response size
-    max_request_size_mb: float = 50.0           # Maximum request size
-    
-    # Connection pool settings
-    max_connections: int = 100                  # Maximum connections in pool
-    max_keepalive_connections: int = 20         # Maximum keep-alive connections
-
+from __future__ import annotations
 
-@dataclass
-class SecurityLimits:
-    """Configuration limits for security operations."""
-    
-    # Path validation
-    allow_absolute_paths: bool = False          # Allow absolute paths
-    allow_symlinks: bool = False                # Allow symbolic links
-    blocked_extensions: tuple = field(default_factory=lambda: (
-        '.exe', '.bat', '.cmd', '.com', '.scr', '.dll', '.sys'
-    ))
-    
-    # Input validation
-    max_input_complexity: int = 1000            # Maximum input complexity score
-    enable_xss_protection: bool = True          # Enable XSS protection
-    enable_injection_protection: bool = True   # Enable injection protection
-    
-    # Cryptography settings
-    min_key_size: int = 2048                    # Minimum key size for RSA
-    hash_iterations: int = 100_000              # PBKDF2 iterations
-    salt_length: int = 32                       # Salt length in bytes
+from dataclasses import dataclass
+import os
 
 
 @dataclass
-class PerformanceLimits:
-    """Master configuration for all XSystem performance limits."""
-    
-    # Component-specific limits
-    serialization: SerializationLimits = field(default_factory=SerializationLimits)
-    network: NetworkLimits = field(default_factory=NetworkLimits)
-    security: SecurityLimits = field(default_factory=SecurityLimits)
-    
-    # Global settings
-    enable_monitoring: bool = True              # Enable performance monitoring
-    enable_metrics: bool = True                 # Enable metrics collection
-    log_performance_warnings: bool = True      # Log performance warnings
-    
-    # Memory management
-    max_total_memory_mb: float = 500.0          # Maximum total memory usage
-    gc_threshold_mb: float = 100.0              # Garbage collection threshold
-    
-    # Concurrency settings
-    max_threads: int = 50                       # Maximum thread pool size
-    max_async_tasks: int = 100                  # Maximum async tasks
-
-
-# Default configuration instance
-DEFAULT_LIMITS: Final[PerformanceLimits] = PerformanceLimits()
-
-
 class PerformanceConfig:
-    """
-    Centralized performance configuration manager.
-    
-    Manages performance limits, timeouts, and optimization settings for XSystem.
-    Supports environment variable overrides and runtime configuration updates.
-    """
-    
-    def __init__(self, config_file: Optional[str] = None) -> None:
-        """
-        Initialize performance configuration.
-        
-        Args:
-            config_file: Optional path to configuration file
-        """
-        self._limits = PerformanceLimits()
-        self._config_file = config_file
-        self._mode = "balanced"  # Default mode
-        self._load_from_environment()
-        
-        if config_file:
-            self._load_from_file(config_file)
-        
-        logger.info("Performance configuration initialized")
-    
-    def _load_from_environment(self) -> None:
-        """Load configuration overrides from environment variables."""
-        
-        # Serialization limits
-        if val := os.getenv('XSYSTEM_MAX_SIZE_MB'):
-            self._limits.serialization.max_size_mb = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_DEPTH'):
-            self._limits.serialization.max_depth = int(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_FILE_SIZE_MB'):
-            self._limits.serialization.max_file_size_mb = float(val)
-        
-        # Network limits
-        if val := os.getenv('XSYSTEM_CONNECT_TIMEOUT'):
-            self._limits.network.connect_timeout = float(val)
-        
-        if val := os.getenv('XSYSTEM_READ_TIMEOUT'):
-            self._limits.network.read_timeout = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_RETRIES'):
-            self._limits.network.max_retries = int(val)
-        
-        # Security limits
-        if val := os.getenv('XSYSTEM_ALLOW_ABSOLUTE_PATHS'):
-            self._limits.security.allow_absolute_paths = val.lower() in ('true', '1', 'yes')
-        
-        if val := os.getenv('XSYSTEM_MIN_KEY_SIZE'):
-            self._limits.security.min_key_size = int(val)
-        
-        # Global settings
-        if val := os.getenv('XSYSTEM_MAX_MEMORY_MB'):
-            self._limits.max_total_memory_mb = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_THREADS'):
-            self._limits.max_threads = int(val)
-    
-    def _load_from_file(self, config_file: str) -> None:
-        """
-        Load configuration from file.
-        
-        Args:
-            config_file: Path to configuration file (JSON/YAML/TOML)
-        """
-        try:
-            config_path = Path(config_file)
-            if not config_path.exists():
-                logger.warning(f"Configuration file not found: {config_file}")
-                return
-            
-            # Import here to avoid circular imports
-            from ..io.serialization import JsonSerializer, YamlSerializer, TomlSerializer
-            
-            # Determine format by extension
-            if config_path.suffix.lower() in ('.json',):
-                serializer = JsonSerializer(validate_paths=False)
-            elif config_path.suffix.lower() in ('.yaml', '.yml'):
-                serializer = YamlSerializer(validate_paths=False)
-            elif config_path.suffix.lower() in ('.toml',):
-                serializer = TomlSerializer(validate_paths=False)
-            else:
-                logger.warning(f"Unsupported config file format: {config_path.suffix}")
-                return
-            
-            config_data = serializer.load_file(config_file)
-            self._apply_config_data(config_data)
-            
-            logger.info(f"Loaded configuration from: {config_file}")
-            
-        except Exception as e:
-            logger.error(f"Failed to load configuration file {config_file}: {e}")
-    
-    def _apply_config_data(self, config_data: dict[str, Any]) -> None:
-        """Apply configuration data to limits."""
-        
-        if 'serialization' in config_data:
-            ser_config = config_data['serialization']
-            for key, value in ser_config.items():
-                if hasattr(self._limits.serialization, key):
-                    setattr(self._limits.serialization, key, value)
-        
-        if 'network' in config_data:
-            net_config = config_data['network']
-            for key, value in net_config.items():
-                if hasattr(self._limits.network, key):
-                    setattr(self._limits.network, key, value)
-        
-        if 'security' in config_data:
-            sec_config = config_data['security']
-            for key, value in sec_config.items():
-                if hasattr(self._limits.security, key):
-                    setattr(self._limits.security, key, value)
-        
-        # Global settings
-        for key in ['enable_monitoring', 'enable_metrics', 'max_total_memory_mb', 'max_threads']:
-            if key in config_data:
-                setattr(self._limits, key, config_data[key])
-    
-    @property
-    def limits(self) -> PerformanceLimits:
-        """Get current performance limits."""
-        return self._limits
-    
-    def get_serialization_config(self) -> dict[str, Any]:
-        """Get serialization configuration dictionary."""
-        return {
-            'max_size_mb': self._limits.serialization.max_size_mb,
-            'max_depth': self._limits.serialization.max_depth,
-            'max_file_size_mb': self._limits.serialization.max_file_size_mb,
-            'use_atomic_writes': self._limits.serialization.use_atomic_writes,
-            'validate_input': self._limits.serialization.validate_input,
-            'validate_paths': self._limits.serialization.validate_paths,
-        }
-    
-    def get_network_config(self) -> dict[str, Any]:
-        """Get network configuration dictionary."""
-        return {
-            'connect_timeout': self._limits.network.connect_timeout,
-            'read_timeout': self._limits.network.read_timeout,
-            'total_timeout': self._limits.network.total_timeout,
-            'max_retries': self._limits.network.max_retries,
-            'max_response_size_mb': self._limits.network.max_response_size_mb,
-        }
-    
-    def get_security_config(self) -> dict[str, Any]:
-        """Get security configuration dictionary."""
-        return {
-            'allow_absolute_paths': self._limits.security.allow_absolute_paths,
-            'allow_symlinks': self._limits.security.allow_symlinks,
-            'blocked_extensions': self._limits.security.blocked_extensions,
-            'min_key_size': self._limits.security.min_key_size,
-        }
-    
-    def update_limits(self, **kwargs) -> None:
-        """
-        Update performance limits at runtime.
-        
-        Args:
-            **kwargs: Limit values to update
-        """
-        for key, value in kwargs.items():
-            if '.' in key:
-                # Handle nested attributes like 'serialization.max_size_mb'
-                parts = key.split('.')
-                obj = self._limits
-                for part in parts[:-1]:
-                    obj = getattr(obj, part)
-                setattr(obj, parts[-1], value)
-            else:
-                # Handle top-level attributes
-                if hasattr(self._limits, key):
-                    setattr(self._limits, key, value)
-        
-        logger.info(f"Updated performance limits: {kwargs}")
-    
-    def set_mode(self, mode: str) -> None:
-        """Set performance mode."""
-        self._mode = mode
-        logger.info(f"Performance mode set to: {mode}")
-    
-    def get_mode(self) -> str:
-        """Get current performance mode."""
-        return self._mode
-    
-    def optimize(self) -> None:
-        """Optimize performance settings based on current mode."""
-        if self._mode == "fast":
-            # Optimize for speed
-            self._limits.serialization.max_size_mb = 100.0
-            self._limits.serialization.max_depth = 200
-        elif self._mode == "memory_optimized":
-            # Optimize for memory
-            self._limits.serialization.max_size_mb = 25.0
-            self._limits.serialization.max_depth = 50
-        else:  # balanced
-            # Balanced settings
-            self._limits.serialization.max_size_mb = 50.0
-            self._limits.serialization.max_depth = 100
-        
-        logger.info(f"Performance optimized for mode: {self._mode}")
-    
-    def export_config(self, format: str = 'json') -> dict[str, Any]:
-        """
-        Export current configuration.
-        
-        Args:
-            format: Export format ('json', 'yaml', 'toml')
-            
-        Returns:
-            Configuration dictionary
-        """
-        return {
-            'serialization': {
-                'max_size_mb': self._limits.serialization.max_size_mb,
-                'max_depth': self._limits.serialization.max_depth,
-                'max_file_size_mb': self._limits.serialization.max_file_size_mb,
-                'use_atomic_writes': self._limits.serialization.use_atomic_writes,
-                'validate_input': self._limits.serialization.validate_input,
-                'validate_paths': self._limits.serialization.validate_paths,
-            },
-            'network': {
-                'connect_timeout': self._limits.network.connect_timeout,
-                'read_timeout': self._limits.network.read_timeout,
-                'total_timeout': self._limits.network.total_timeout,
-                'max_retries': self._limits.network.max_retries,
-                'max_response_size_mb': self._limits.network.max_response_size_mb,
-            },
-            'security': {
-                'allow_absolute_paths': self._limits.security.allow_absolute_paths,
-                'allow_symlinks': self._limits.security.allow_symlinks,
-                'min_key_size': self._limits.security.min_key_size,
-            },
-            'global': {
-                'enable_monitoring': self._limits.enable_monitoring,
-                'enable_metrics': self._limits.enable_metrics,
-                'max_total_memory_mb': self._limits.max_total_memory_mb,
-                'max_threads': self._limits.max_threads,
-            }
-        }
-
-
-# Global configuration instance
-_global_config: Optional[PerformanceConfig] = None
+    """Configuration for performance optimizations."""
+    
+    # Parallel index building
+    enable_parallel_index: bool = True  # Auto-enabled for large files
+    parallel_index_workers: int | None = None  # None = auto (CPU count)
+    parallel_index_chunk_size_mb: int = 100  # 100MB chunks
+    parallel_index_threshold_mb: int = 200  # Use parallel for files >200MB
+    
+    # Append-only log for atomic updates
+    enable_append_log: bool = True  # Auto-enabled for large files
+    append_log_threshold_mb: int = 100  # Use append-only log for files >100MB
+    append_log_compaction_threshold_mb: int = 100  # Compact when log > 100MB
+    
+    # Fallback behavior
+    fallback_on_error: bool = True  # Fall back to original if optimization fails
+    
+    @classmethod
+    def from_env(cls) -> PerformanceConfig:
+        """Create config from environment variables."""
+        return cls(
+            enable_parallel_index=os.getenv("XWSYSTEM_PARALLEL_INDEX", "true").lower() == "true",
+            parallel_index_workers=int(os.getenv("XWSYSTEM_PARALLEL_WORKERS", "0")) or None,
+            parallel_index_chunk_size_mb=int(os.getenv("XWSYSTEM_CHUNK_SIZE_MB", "100")),
+            parallel_index_threshold_mb=int(os.getenv("XWSYSTEM_PARALLEL_THRESHOLD_MB", "200")),
+            enable_append_log=os.getenv("XWSYSTEM_APPEND_LOG", "true").lower() == "true",
+            append_log_threshold_mb=int(os.getenv("XWSYSTEM_APPEND_LOG_THRESHOLD_MB", "100")),
+            append_log_compaction_threshold_mb=int(os.getenv("XWSYSTEM_LOG_THRESHOLD_MB", "100")),
+            fallback_on_error=os.getenv("XWSYSTEM_FALLBACK", "true").lower() == "true",
+        )
+    
+    @classmethod
+    def conservative(cls) -> PerformanceConfig:
+        """Conservative config (disable optimizations, use originals)."""
+        return cls(
+            enable_parallel_index=False,
+            enable_append_log=False,
+            fallback_on_error=True,
+        )
+    
+    @classmethod
+    def aggressive(cls) -> PerformanceConfig:
+        """Aggressive config (enable all optimizations, no fallback)."""
+        return cls(
+            enable_parallel_index=True,
+            enable_append_log=True,
+            fallback_on_error=False,
+        )
+
+
+# Global config instance
+_config: PerformanceConfig | None = None
 
 
 def get_performance_config() -> PerformanceConfig:
-    """Get the global performance configuration instance."""
-    global _global_config
-    if _global_config is None:
-        _global_config = PerformanceConfig()
-    return _global_config
-
+    """Get global performance config."""
+    global _config
+    if _config is None:
+        _config = PerformanceConfig.from_env()
+    return _config
 
-def configure_performance(config_file: Optional[str] = None, **kwargs) -> None:
-    """
-    Configure global performance settings.
-    
-    Args:
-        config_file: Optional configuration file path
-        **kwargs: Performance limit overrides
-    """
-    global _global_config
-    _global_config = PerformanceConfig(config_file)
-    
-    if kwargs:
-        _global_config.update_limits(**kwargs)
 
+def set_performance_config(config: PerformanceConfig) -> None:
+    """Set global performance config."""
+    global _config
+    _config = config
 
-# Convenience functions for getting specific limits
-def get_serialization_limits() -> SerializationLimits:
-    """Get current serialization limits."""
-    return get_performance_config().limits.serialization
 
+# Placeholder classes for backward compatibility with existing config system
+# These are not used by the new optimization system but are required by __init__.py
+@dataclass
+class PerformanceLimits:
+    """Placeholder for backward compatibility."""
+    pass
 
-def get_network_limits() -> NetworkLimits:
-    """Get current network limits."""
-    return get_performance_config().limits.network
+@dataclass
+class SerializationLimits:
+    """Placeholder for backward compatibility."""
+    pass
 
+@dataclass
+class NetworkLimits:
+    """Placeholder for backward compatibility."""
+    pass
 
-def get_security_limits() -> SecurityLimits:
-    """Get current security limits."""
-    return get_performance_config().limits.security
+@dataclass
+class SecurityLimits:
+    """Placeholder for backward compatibility."""
+    pass
+
+def configure_performance(**kwargs):
+    """Placeholder for backward compatibility."""
+    pass
+
+def get_serialization_limits():
+    """Placeholder for backward compatibility."""
+    return SerializationLimits()
+
+def get_network_limits():
+    """Placeholder for backward compatibility."""
+    return NetworkLimits()
+
+def get_security_limits():
+    """Placeholder for backward compatibility."""
+    return SecurityLimits()
+
+__all__ = [
+    "PerformanceConfig",
+    "PerformanceLimits",
+    "SerializationLimits",
+    "NetworkLimits",
+    "SecurityLimits",
+    "get_performance_config",
+    "set_performance_config",
+    "configure_performance",
+    "get_serialization_limits",
+    "get_network_limits",
+    "get_security_limits",
+]

exonware/xwsystem/http_client/__init__.py

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

exonware/xwsystem/http_client/advanced_client.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 Advanced HTTP client with HTTP/2, streaming, pluggable transports, and modern features.
@@ -28,7 +28,7 @@ from ..config.logging_setup import get_logger
 from ..monitoring.error_recovery import retry_with_backoff
 from .client import HttpError, RetryConfig
 
-logger = get_logger("xsystem.http_client.advanced_client")
+logger = get_logger("xwsystem.http_client.advanced_client")
 
 
 

exonware/xwsystem/http_client/base.py

@@ -1,9 +1,9 @@
-#exonware/xsystem/http/base.py
+#exonware/xwsystem/http/base.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 HTTP module base classes - abstract classes for HTTP client functionality.

exonware/xwsystem/http_client/client.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 HTTP client with retry mechanisms, connection pooling, and error handling.
@@ -24,7 +24,7 @@ from ..config.logging_setup import get_logger
 from ..monitoring.error_recovery import retry_with_backoff
 from .errors import HttpError
 
-logger = get_logger("xsystem.http_client.client")
+logger = get_logger("xwsystem.http_client.client")
 
 
 @dataclass

exonware/xwsystem/http_client/contracts.py

@@ -2,7 +2,7 @@
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.410
+Version: 0.1.0.1
 Generation Date: September 04, 2025
 
 HTTP module contracts - interfaces and enums for HTTP client functionality.

exonware/xwsystem/http_client/defs.py

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