Update app_config.py

app_config.py

@@ -1,14 +1,17 @@
 """
-Application Configuration Module
+BackgroundFX Pro Configuration Module
 Centralizes all application configuration and environment variable handling
 
 Note: Named 'app_config.py' to avoid conflicts with existing 'Configs/' folder
 """
 
 import os
-from dataclasses import dataclass, asdict
-from typing import Dict, Any, Optional
+from dataclasses import dataclass, asdict, field
+from typing import Dict, Any, Optional, List
+from pathlib import Path
 import logging
+import json
+import yaml
 
 logger = logging.getLogger(__name__)
 
@@ -17,16 +20,23 @@ class ProcessingConfig:
     """
     Main processing configuration with environment variable defaults
     """
+    # Application info
+    app_name: str = "BackgroundFX Pro"
+    version: str = "2.0.0"
+    
     # Frame processing settings
     keyframe_interval: int = int(os.getenv('KEYFRAME_INTERVAL', '5'))
     frame_skip: int = int(os.getenv('FRAME_SKIP', '1'))
     
     # Memory management
     memory_cleanup_interval: int = int(os.getenv('MEMORY_CLEANUP_INTERVAL', '30'))
+    memory_threshold_mb: int = int(os.getenv('MEMORY_THRESHOLD_MB', '1024'))
     
     # Video constraints
     max_video_length: int = int(os.getenv('MAX_VIDEO_LENGTH', '300'))  # seconds
     max_video_resolution: str = os.getenv('MAX_VIDEO_RESOLUTION', '1920x1080')
+    min_video_fps: int = int(os.getenv('MIN_VIDEO_FPS', '15'))
+    max_video_fps: int = int(os.getenv('MAX_VIDEO_FPS', '60'))
     
     # Quality settings
     quality_preset: str = os.getenv('QUALITY_PRESET', 'balanced')
@@ -34,56 +44,82 @@ class ProcessingConfig:
     # Model settings
     sam2_model_size: str = os.getenv('SAM2_MODEL_SIZE', 'large')  # tiny, small, base, large
     matanyone_precision: str = os.getenv('MATANYONE_PRECISION', 'fp32')  # fp16, fp32
+    model_device: str = os.getenv('MODEL_DEVICE', 'auto')  # auto, cuda, cpu
     
     # Processing settings
     temporal_consistency: bool = os.getenv('TEMPORAL_CONSISTENCY', 'true').lower() == 'true'
     edge_refinement: bool = os.getenv('EDGE_REFINEMENT', 'true').lower() == 'true'
+    mask_blur_radius: int = int(os.getenv('MASK_BLUR_RADIUS', '5'))
+    confidence_threshold: float = float(os.getenv('CONFIDENCE_THRESHOLD', '0.85'))
     
     # Output settings
+    output_dir: str = os.getenv('OUTPUT_DIR', 'outputs')
     output_format: str = os.getenv('OUTPUT_FORMAT', 'mp4')
     output_quality: str = os.getenv('OUTPUT_QUALITY', 'high')  # low, medium, high
+    output_codec: str = os.getenv('OUTPUT_CODEC', 'h264')
     preserve_audio: bool = os.getenv('PRESERVE_AUDIO', 'true').lower() == 'true'
     
     # Cache settings
-    model_cache_dir: str = os.getenv('MODEL_CACHE_DIR', '/tmp/model_cache')
-    temp_dir: str = os.getenv('TEMP_DIR', '/tmp')
+    model_cache_dir: str = os.getenv('MODEL_CACHE_DIR', 'models/cache')
+    temp_dir: str = os.getenv('TEMP_DIR', 'temp')
     cleanup_temp_files: bool = os.getenv('CLEANUP_TEMP_FILES', 'true').lower() == 'true'
+    cache_size_limit_gb: float = float(os.getenv('CACHE_SIZE_LIMIT_GB', '10.0'))
     
     # Performance settings
     max_concurrent_processes: int = int(os.getenv('MAX_CONCURRENT_PROCESSES', '1'))
     gpu_memory_fraction: float = float(os.getenv('GPU_MEMORY_FRACTION', '0.8'))
+    batch_size: int = int(os.getenv('BATCH_SIZE', '4'))
+    num_workers: int = int(os.getenv('NUM_WORKERS', '4'))
+    
+    # API settings
+    api_enabled: bool = os.getenv('API_ENABLED', 'false').lower() == 'true'
+    api_host: str = os.getenv('API_HOST', '0.0.0.0')
+    api_port: int = int(os.getenv('API_PORT', '8000'))
+    api_key: Optional[str] = os.getenv('API_KEY', None)
+    
+    # Web UI settings
+    gradio_server_name: str = os.getenv('GRADIO_SERVER_NAME', '0.0.0.0')
+    gradio_server_port: int = int(os.getenv('GRADIO_SERVER_PORT', '7860'))
+    gradio_share: bool = os.getenv('GRADIO_SHARE', 'false').lower() == 'true'
+    gradio_auth: Optional[str] = os.getenv('GRADIO_AUTH', None)  # username:password
     
     # Debug settings
     debug_mode: bool = os.getenv('DEBUG_MODE', 'false').lower() == 'true'
     save_intermediate_results: bool = os.getenv('SAVE_INTERMEDIATE_RESULTS', 'false').lower() == 'true'
+    log_level: str = os.getenv('LOG_LEVEL', 'INFO')
+    profile_performance: bool = os.getenv('PROFILE_PERFORMANCE', 'false').lower() == 'true'
+    
+    # Feature flags
+    enable_two_stage: bool = os.getenv('ENABLE_TWO_STAGE', 'true').lower() == 'true'
+    enable_preview_modes: bool = os.getenv('ENABLE_PREVIEW_MODES', 'true').lower() == 'true'
+    enable_batch_processing: bool = os.getenv('ENABLE_BATCH_PROCESSING', 'false').lower() == 'true'
+    
+    # Legacy compatibility
+    legacy_mode: bool = os.getenv('LEGACY_MODE', 'true').lower() == 'true'
+    legacy_configs_dir: str = os.getenv('LEGACY_CONFIGS_DIR', 'Configs')
     
     def __post_init__(self):
         """Validate configuration after initialization"""
         self._validate_config()
         self._create_directories()
+        self._setup_logging()
         if self.debug_mode:
             self._log_config()
     
     def _validate_config(self):
         """Validate configuration values"""
         # Validate frame settings
-        if self.keyframe_interval < 1:
-            logger.warning(f"keyframe_interval must be >= 1, got {self.keyframe_interval}. Setting to 1.")
-            self.keyframe_interval = 1
-        
-        if self.frame_skip < 1:
-            logger.warning(f"frame_skip must be >= 1, got {self.frame_skip}. Setting to 1.")
-            self.frame_skip = 1
+        self.keyframe_interval = max(1, self.keyframe_interval)
+        self.frame_skip = max(1, self.frame_skip)
         
         # Validate memory settings
-        if self.memory_cleanup_interval < 1:
-            logger.warning(f"memory_cleanup_interval must be >= 1, got {self.memory_cleanup_interval}. Setting to 10.")
-            self.memory_cleanup_interval = 10
+        self.memory_cleanup_interval = max(1, self.memory_cleanup_interval)
+        self.memory_threshold_mb = max(256, self.memory_threshold_mb)
         
         # Validate video constraints
-        if self.max_video_length < 1:
-            logger.warning(f"max_video_length must be >= 1, got {self.max_video_length}. Setting to 60.")
-            self.max_video_length = 60
+        self.max_video_length = max(1, self.max_video_length)
+        self.min_video_fps = max(1, min(self.min_video_fps, 60))
+        self.max_video_fps = max(self.min_video_fps, min(self.max_video_fps, 120))
         
         # Validate resolution format
         if 'x' not in self.max_video_resolution:
@@ -108,48 +144,115 @@ def _validate_config(self):
             self.matanyone_precision = 'fp32'
         
         # Validate output settings
-        valid_formats = ['mp4', 'avi', 'mov', 'webm']
+        valid_formats = ['mp4', 'avi', 'mov', 'webm', 'mkv']
         if self.output_format not in valid_formats:
             logger.warning(f"Invalid output format: {self.output_format}. Setting to 'mp4'.")
             self.output_format = 'mp4'
         
-        valid_qualities = ['low', 'medium', 'high']
+        valid_qualities = ['low', 'medium', 'high', 'ultra']
         if self.output_quality not in valid_qualities:
             logger.warning(f"Invalid output quality: {self.output_quality}. Setting to 'high'.")
             self.output_quality = 'high'
         
         # Validate performance settings
-        if self.max_concurrent_processes < 1:
-            logger.warning(f"max_concurrent_processes must be >= 1, got {self.max_concurrent_processes}. Setting to 1.")
-            self.max_concurrent_processes = 1
+        self.max_concurrent_processes = max(1, self.max_concurrent_processes)
+        self.gpu_memory_fraction = max(0.1, min(1.0, self.gpu_memory_fraction))
+        self.batch_size = max(1, self.batch_size)
+        self.num_workers = max(0, self.num_workers)
+        
+        # Validate API settings
+        self.api_port = max(1024, min(65535, self.api_port))
+        
+        # Validate confidence threshold
+        self.confidence_threshold = max(0.0, min(1.0, self.confidence_threshold))
         
-        if not (0.1 <= self.gpu_memory_fraction <= 1.0):
-            logger.warning(f"gpu_memory_fraction must be between 0.1 and 1.0, got {self.gpu_memory_fraction}. Setting to 0.8.")
-            self.gpu_memory_fraction = 0.8
+        # Validate cache size
+        self.cache_size_limit_gb = max(0.1, self.cache_size_limit_gb)
     
     def _create_directories(self):
         """Create necessary directories if they don't exist"""
-        import os
-        directories = [self.model_cache_dir, self.temp_dir]
+        directories = [
+            self.model_cache_dir,
+            self.temp_dir,
+            self.output_dir,
+            Path(self.output_dir) / 'masks',
+            Path(self.output_dir) / 'greenscreen',
+            Path(self.output_dir) / 'final',
+            Path(self.output_dir) / 'two_stage'
+        ]
         
         for directory in directories:
             try:
-                os.makedirs(directory, exist_ok=True)
+                Path(directory).mkdir(parents=True, exist_ok=True)
                 logger.debug(f"Ensured directory exists: {directory}")
             except Exception as e:
                 logger.error(f"Failed to create directory {directory}: {e}")
     
+    def _setup_logging(self):
+        """Setup logging based on configuration"""
+        log_levels = {
+            'DEBUG': logging.DEBUG,
+            'INFO': logging.INFO,
+            'WARNING': logging.WARNING,
+            'ERROR': logging.ERROR,
+            'CRITICAL': logging.CRITICAL
+        }
+        
+        level = log_levels.get(self.log_level.upper(), logging.INFO)
+        logging.getLogger().setLevel(level)
+    
     def _log_config(self):
         """Log current configuration in debug mode"""
-        logger.info("=== Processing Configuration ===")
-        for key, value in asdict(self).items():
+        logger.info("=" * 60)
+        logger.info(f"{self.app_name} v{self.version} Configuration")
+        logger.info("=" * 60)
+        config_dict = self.to_dict()
+        # Hide sensitive information
+        if config_dict.get('api_key'):
+            config_dict['api_key'] = '***hidden***'
+        if config_dict.get('gradio_auth'):
+            config_dict['gradio_auth'] = '***hidden***'
+        
+        for key, value in config_dict.items():
             logger.info(f"{key}: {value}")
-        logger.info("===============================")
+        logger.info("=" * 60)
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert configuration to dictionary"""
         return asdict(self)
     
+    def to_json(self, filepath: Optional[str] = None) -> str:
+        """Export configuration to JSON"""
+        config_dict = self.to_dict()
+        if filepath:
+            with open(filepath, 'w') as f:
+                json.dump(config_dict, f, indent=2)
+            logger.info(f"Configuration saved to {filepath}")
+        return json.dumps(config_dict, indent=2)
+    
+    def to_yaml(self, filepath: Optional[str] = None) -> str:
+        """Export configuration to YAML"""
+        config_dict = self.to_dict()
+        if filepath:
+            with open(filepath, 'w') as f:
+                yaml.dump(config_dict, f, default_flow_style=False)
+            logger.info(f"Configuration saved to {filepath}")
+        return yaml.dump(config_dict, default_flow_style=False)
+    
+    @classmethod
+    def from_json(cls, filepath: str) -> 'ProcessingConfig':
+        """Load configuration from JSON file"""
+        with open(filepath, 'r') as f:
+            config_dict = json.load(f)
+        return cls(**config_dict)
+    
+    @classmethod
+    def from_yaml(cls, filepath: str) -> 'ProcessingConfig':
+        """Load configuration from YAML file"""
+        with open(filepath, 'r') as f:
+            config_dict = yaml.safe_load(f)
+        return cls(**config_dict)
+    
     def get_quality_settings(self) -> Dict[str, Any]:
         """Get quality-specific settings based on preset"""
         quality_maps = {
@@ -158,28 +261,36 @@ def get_quality_settings(self) -> Dict[str, Any]:
                 'frame_skip': max(self.frame_skip, 2),
                 'edge_refinement': False,
                 'temporal_consistency': False,
-                'model_precision': 'fp16'
+                'model_precision': 'fp16',
+                'batch_size': min(self.batch_size * 2, 16),
+                'output_quality_params': '-preset ultrafast -crf 28'
             },
             'balanced': {
                 'keyframe_interval': self.keyframe_interval,
                 'frame_skip': self.frame_skip,
                 'edge_refinement': True,
                 'temporal_consistency': True,
-                'model_precision': 'fp32'
+                'model_precision': 'fp32',
+                'batch_size': self.batch_size,
+                'output_quality_params': '-preset medium -crf 23'
             },
             'high': {
                 'keyframe_interval': max(self.keyframe_interval // 2, 1),
                 'frame_skip': 1,
                 'edge_refinement': True,
                 'temporal_consistency': True,
-                'model_precision': 'fp32'
+                'model_precision': 'fp32',
+                'batch_size': max(self.batch_size // 2, 1),
+                'output_quality_params': '-preset slow -crf 18'
             },
             'ultra': {
                 'keyframe_interval': 1,
                 'frame_skip': 1,
                 'edge_refinement': True,
                 'temporal_consistency': True,
-                'model_precision': 'fp32'
+                'model_precision': 'fp32',
+                'batch_size': 1,
+                'output_quality_params': '-preset veryslow -crf 15'
             }
         }
         
@@ -194,6 +305,23 @@ def get_resolution_limits(self) -> tuple[int, int]:
             logger.error(f"Invalid resolution format: {self.max_video_resolution}")
             return 1920, 1080
     
+    def get_output_params(self) -> Dict[str, str]:
+        """Get FFmpeg output parameters based on settings"""
+        quality_settings = self.get_quality_settings()
+        codec_map = {
+            'h264': 'libx264',
+            'h265': 'libx265',
+            'vp9': 'libvpx-vp9',
+            'av1': 'libaom-av1'
+        }
+        
+        return {
+            'codec': codec_map.get(self.output_codec, 'libx264'),
+            'quality': quality_settings['output_quality_params'],
+            'format': self.output_format,
+            'audio': '-c:a copy' if self.preserve_audio else '-an'
+        }
+    
     def is_high_performance_mode(self) -> bool:
         """Check if configuration is set for high performance"""
         return (
@@ -203,13 +331,42 @@ def is_high_performance_mode(self) -> bool:
             self.keyframe_interval <= 3
         )
     
-    def get_memory_limits(self) -> Dict[str, float]:
+    def get_memory_limits(self) -> Dict[str, Any]:
         """Get memory-related limits"""
         return {
             'gpu_memory_fraction': self.gpu_memory_fraction,
             'cleanup_interval': self.memory_cleanup_interval,
-            'max_concurrent': self.max_concurrent_processes
+            'max_concurrent': self.max_concurrent_processes,
+            'threshold_mb': self.memory_threshold_mb,
+            'cache_size_gb': self.cache_size_limit_gb
         }
+    
+    def validate_for_production(self) -> List[str]:
+        """Validate configuration for production deployment"""
+        warnings = []
+        
+        if self.debug_mode:
+            warnings.append("Debug mode is enabled in production")
+        
+        if self.save_intermediate_results:
+            warnings.append("Intermediate results saving is enabled (disk usage)")
+        
+        if not self.cleanup_temp_files:
+            warnings.append("Temp file cleanup is disabled (disk usage)")
+        
+        if self.gradio_share:
+            warnings.append("Gradio share is enabled (security risk)")
+        
+        if not self.api_key and self.api_enabled:
+            warnings.append("API is enabled without authentication")
+        
+        if self.gpu_memory_fraction > 0.9:
+            warnings.append("GPU memory fraction is very high (>90%)")
+        
+        if self.max_concurrent_processes > 4:
+            warnings.append("High concurrent processes may cause instability")
+        
+        return warnings
 
 # Singleton instance for application-wide use
 _config_instance: Optional[ProcessingConfig] = None
@@ -243,4 +400,22 @@ def update_config(**kwargs) -> ProcessingConfig:
     
     # Re-validate after updates
     _config_instance._validate_config()
+    return _config_instance
+
+def load_config_from_file(filepath: str) -> ProcessingConfig:
+    """Load configuration from file (JSON or YAML)"""
+    global _config_instance
+    
+    file_path = Path(filepath)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {filepath}")
+    
+    if file_path.suffix.lower() in ['.json']:
+        _config_instance = ProcessingConfig.from_json(filepath)
+    elif file_path.suffix.lower() in ['.yaml', '.yml']:
+        _config_instance = ProcessingConfig.from_yaml(filepath)
+    else:
+        raise ValueError(f"Unsupported configuration file format: {file_path.suffix}")
+    
+    logger.info(f"Configuration loaded from {filepath}")
     return _config_instance