Create path_config.py

path_config.py

@@ -0,0 +1,246 @@
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class EnvironmentPathManager:
+    """Dynamic path management for different deployment environments"""
+    
+    def __init__(self):
+        self.environment = self._detect_environment()
+        self.base_paths = self._configure_paths()
+        self._ensure_directories()
+        
+    def _detect_environment(self) -> str:
+        """Detect the current deployment environment"""
+        # Check for HuggingFace Spaces
+        if os.environ.get('SPACE_ID') or os.path.exists('/app/app.py') or os.path.exists('/app/streamlit_app.py'):
+            return 'huggingface_spaces'
+        
+        # Check for Docker container
+        if os.path.exists('/.dockerenv') or os.environ.get('DOCKER_CONTAINER'):
+            return 'docker'
+        
+        # Check if running from /app directory (likely container)
+        if str(Path.cwd()).startswith('/app'):
+            return 'container'
+            
+        # Default to local development
+        return 'local'
+    
+    def _configure_paths(self) -> Dict[str, Path]:
+        """Configure paths based on environment"""
+        if self.environment == 'huggingface_spaces':
+            # HuggingFace Spaces: Use /app structure
+            base_dir = Path('/app')
+            return {
+                'base': base_dir,
+                'data': base_dir / 'data',
+                'model': base_dir / 'model', 
+                'logs': base_dir / 'logs',
+                'cache': base_dir / 'cache',
+                'temp': base_dir / 'temp'
+            }
+            
+        elif self.environment in ['docker', 'container']:
+            # Docker/Container: Use /app structure with /tmp for temporary files
+            base_dir = Path('/app')
+            return {
+                'base': base_dir,
+                'data': base_dir / 'data',
+                'model': base_dir / 'model',
+                'logs': base_dir / 'logs', 
+                'cache': Path('/tmp/cache'),
+                'temp': Path('/tmp/temp')
+            }
+            
+        else:
+            # Local development: Use project structure
+            # Find project root (where this file is located)
+            current_file = Path(__file__).resolve()
+            project_root = current_file.parent
+            
+            # Navigate up to find the actual project root
+            while project_root.parent != project_root:
+                if (project_root / 'requirements.txt').exists():
+                    break
+                project_root = project_root.parent
+            
+            return {
+                'base': project_root,
+                'data': project_root / 'data',
+                'model': project_root / 'model',
+                'logs': project_root / 'logs',
+                'cache': project_root / 'cache',
+                'temp': project_root / 'temp'
+            }
+    
+    def _ensure_directories(self):
+        """Ensure all necessary directories exist"""
+        for path_name, path in self.base_paths.items():
+            try:
+                path.mkdir(parents=True, exist_ok=True)
+                logger.debug(f"Ensured directory exists: {path}")
+            except PermissionError:
+                logger.warning(f"Cannot create directory {path}, using fallback")
+                if path_name in ['cache', 'temp']:
+                    # Fallback to user's home directory for cache/temp
+                    fallback_path = Path.home() / f'.fake_news_detector/{path_name}'
+                    fallback_path.mkdir(parents=True, exist_ok=True)
+                    self.base_paths[path_name] = fallback_path
+            except Exception as e:
+                logger.error(f"Failed to create directory {path}: {e}")
+    
+    def get_data_path(self, filename: str = '') -> Path:
+        """Get data directory path"""
+        return self.base_paths['data'] / filename if filename else self.base_paths['data']
+    
+    def get_model_path(self, filename: str = '') -> Path:
+        """Get model directory path"""
+        return self.base_paths['model'] / filename if filename else self.base_paths['model']
+    
+    def get_logs_path(self, filename: str = '') -> Path:
+        """Get logs directory path"""  
+        return self.base_paths['logs'] / filename if filename else self.base_paths['logs']
+    
+    def get_cache_path(self, filename: str = '') -> Path:
+        """Get cache directory path"""
+        return self.base_paths['cache'] / filename if filename else self.base_paths['cache']
+    
+    def get_temp_path(self, filename: str = '') -> Path:
+        """Get temporary directory path"""
+        return self.base_paths['temp'] / filename if filename else self.base_paths['temp']
+    
+    def get_activity_log_path(self) -> Path:
+        """Get activity log file path"""
+        return self.get_logs_path('activity_log.json')
+    
+    def get_metadata_path(self) -> Path:
+        """Get model metadata file path"""
+        return self.get_model_path('metadata.json')
+    
+    def get_combined_dataset_path(self) -> Path:
+        """Get combined dataset path"""
+        return self.get_data_path('combined_dataset.csv')
+    
+    def get_scraped_data_path(self) -> Path:
+        """Get scraped data path"""
+        return self.get_data_path('scraped_real.csv')
+    
+    def get_generated_data_path(self) -> Path:
+        """Get generated fake data path"""
+        return self.get_data_path('generated_fake.csv')
+    
+    def get_model_file_path(self) -> Path:
+        """Get main model file path"""
+        return self.get_model_path('model.pkl')
+    
+    def get_vectorizer_path(self) -> Path:
+        """Get vectorizer file path"""
+        return self.get_model_path('vectorizer.pkl')
+    
+    def get_pipeline_path(self) -> Path:
+        """Get pipeline file path"""
+        return self.get_model_path('pipeline.pkl')
+    
+    def get_candidate_model_path(self) -> Path:
+        """Get candidate model file path"""
+        return self.get_model_path('model_candidate.pkl')
+    
+    def get_candidate_vectorizer_path(self) -> Path:
+        """Get candidate vectorizer file path"""
+        return self.get_model_path('vectorizer_candidate.pkl')
+    
+    def get_candidate_pipeline_path(self) -> Path:
+        """Get candidate pipeline file path"""
+        return self.get_model_path('pipeline_candidate.pkl')
+    
+    def list_available_datasets(self) -> Dict[str, bool]:
+        """List available datasets and their existence status"""
+        datasets = {
+            'combined_dataset.csv': self.get_combined_dataset_path().exists(),
+            'scraped_real.csv': self.get_scraped_data_path().exists(), 
+            'generated_fake.csv': self.get_generated_data_path().exists(),
+            'kaggle/Fake.csv': (self.get_data_path() / 'kaggle' / 'Fake.csv').exists(),
+            'kaggle/True.csv': (self.get_data_path() / 'kaggle' / 'True.csv').exists(),
+        }
+        return datasets
+    
+    def list_available_models(self) -> Dict[str, bool]:
+        """List available models and their existence status"""
+        models = {
+            'model.pkl': self.get_model_file_path().exists(),
+            'vectorizer.pkl': self.get_vectorizer_path().exists(),
+            'pipeline.pkl': self.get_pipeline_path().exists(),
+            'model_candidate.pkl': self.get_candidate_model_path().exists(),
+            'vectorizer_candidate.pkl': self.get_candidate_vectorizer_path().exists(),
+            'pipeline_candidate.pkl': self.get_candidate_pipeline_path().exists(),
+            'metadata.json': self.get_metadata_path().exists()
+        }
+        return models
+    
+    def get_environment_info(self) -> Dict:
+        """Get comprehensive environment information"""
+        return {
+            'environment': self.environment,
+            'base_dir': str(self.base_paths['base']),
+            'data_dir': str(self.base_paths['data']),
+            'model_dir': str(self.base_paths['model']),
+            'logs_dir': str(self.base_paths['logs']),
+            'available_datasets': self.list_available_datasets(),
+            'available_models': self.list_available_models(),
+            'current_working_directory': str(Path.cwd()),
+            'python_path': sys.path[0],
+            'space_id': os.environ.get('SPACE_ID', 'Not HF Spaces'),
+            'docker_env': os.path.exists('/.dockerenv')
+        }
+    
+    def log_environment_info(self):
+        """Log detailed environment information"""
+        info = self.get_environment_info()
+        logger.info(f"🌍 Environment: {info['environment']}")
+        logger.info(f"📁 Base directory: {info['base_dir']}")
+        logger.info(f"📊 Data directory: {info['data_dir']}")
+        logger.info(f"🤖 Model directory: {info['model_dir']}")
+        logger.info(f"📝 Logs directory: {info['logs_dir']}")
+        
+        # Log available files
+        datasets = info['available_datasets']
+        models = info['available_models']
+        
+        logger.info(f"📈 Available datasets: {sum(datasets.values())}/{len(datasets)}")
+        for name, exists in datasets.items():
+            status = "✅" if exists else "❌"
+            logger.info(f"  {status} {name}")
+            
+        logger.info(f"🎯 Available models: {sum(models.values())}/{len(models)}")
+        for name, exists in models.items():
+            status = "✅" if exists else "❌"
+            logger.info(f"  {status} {name}")
+
+# Global instance
+path_manager = EnvironmentPathManager()
+
+# Convenience functions for backward compatibility
+def get_data_path(filename: str = '') -> Path:
+    return path_manager.get_data_path(filename)
+
+def get_model_path(filename: str = '') -> Path:
+    return path_manager.get_model_path(filename)
+
+def get_logs_path(filename: str = '') -> Path:
+    return path_manager.get_logs_path(filename)
+
+def get_environment_info() -> Dict:
+    return path_manager.get_environment_info()
+
+def log_environment_info():
+    path_manager.log_environment_info()
+
+# For debugging
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    log_environment_info()