ajout dun systeme de config pour les engines

Author: raidos23

Core/engines_loader/__init__.py

@@ -22,6 +22,11 @@
 
 from . import registry as registry  # re-export registry module
 from .base import CompilerEngine  # re-export base type
+from .config_manager import (
+    EnginesConfigManager,
+    get_engines_config_manager,
+    reset_engines_config_manager,
+)
 from .validator import (
     EngineCompatibilityCheckResult,
     check_engine_compatibility,
@@ -89,4 +94,10 @@ def _auto_discover() -> None:
 except Exception:
     pass
 
-__all__ = ["CompilerEngine", "registry"]
+__all__ = [
+    "CompilerEngine",
+    "registry",
+    "EnginesConfigManager",
+    "get_engines_config_manager",
+    "reset_engines_config_manager",
+]

Core/engines_loader/config_manager.py

@@ -0,0 +1,280 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 Ague Samuel Amen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Engines Configuration Manager
+Manages engine-specific configurations stored in ark_engines_config directory
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional, Dict
+
+
+class EnginesConfigManager:
+    """
+    Manages engine configurations in a centralized directory structure.
+    
+    Directory structure:
+    workspace_root/
+    └── ark_engines_config/
+        ├── engine_id_1/
+        │   └── config.json
+        ├── engine_id_2/
+        │   └── config.json
+        └── ...
+    """
+
+    CONFIG_DIR_NAME = "ark_engines_config"
+    CONFIG_FILENAME = "config.json"
+
+    def __init__(self, workspace_dir: str):
+        """
+        Initialize the engines config manager.
+        
+        Args:
+            workspace_dir: Root directory of the workspace
+        """
+        self.workspace_dir = Path(workspace_dir) if workspace_dir else None
+        self._config_root = None
+        self._ensure_config_root()
+
+    def _ensure_config_root(self) -> None:
+        """Ensure the ark_engines_config directory exists at workspace root."""
+        if not self.workspace_dir:
+            return
+        
+        self._config_root = self.workspace_dir / self.CONFIG_DIR_NAME
+        try:
+            self._config_root.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            print(f"Warning: Failed to create engines config directory: {e}")
+            self._config_root = None
+
+    def get_engine_config_dir(self, engine_id: str) -> Optional[Path]:
+        """
+        Get or create the configuration directory for a specific engine.
+        
+        Args:
+            engine_id: The engine identifier
+            
+        Returns:
+            Path to the engine's config directory, or None if creation failed
+        """
+        if not self._config_root or not engine_id:
+            return None
+        
+        engine_config_dir = self._config_root / engine_id
+        try:
+            engine_config_dir.mkdir(parents=True, exist_ok=True)
+            return engine_config_dir
+        except Exception as e:
+            print(f"Warning: Failed to create config directory for engine '{engine_id}': {e}")
+            return None
+
+    def get_engine_config_file(self, engine_id: str) -> Optional[Path]:
+        """
+        Get the configuration file path for a specific engine.
+        
+        Args:
+            engine_id: The engine identifier
+            
+        Returns:
+            Path to the engine's config.json file, or None if directory creation failed
+        """
+        engine_dir = self.get_engine_config_dir(engine_id)
+        if not engine_dir:
+            return None
+        return engine_dir / self.CONFIG_FILENAME
+
+    def load_engine_config(self, engine_id: str) -> Dict[str, Any]:
+        """
+        Load configuration for a specific engine.
+        
+        Args:
+            engine_id: The engine identifier
+            
+        Returns:
+            Dictionary containing the engine configuration, or empty dict if not found
+        """
+        config_file = self.get_engine_config_file(engine_id)
+        if not config_file or not config_file.exists():
+            return {}
+        
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                config = json.load(f)
+                return config if isinstance(config, dict) else {}
+        except Exception as e:
+            print(f"Warning: Failed to load config for engine '{engine_id}': {e}")
+            return {}
+
+    def save_engine_config(self, engine_id: str, config: Dict[str, Any]) -> bool:
+        """
+        Save configuration for a specific engine.
+        
+        Args:
+            engine_id: The engine identifier
+            config: Dictionary containing the configuration to save
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not isinstance(config, dict):
+            print(f"Warning: Config for engine '{engine_id}' must be a dictionary")
+            return False
+        
+        config_file = self.get_engine_config_file(engine_id)
+        if not config_file:
+            return False
+        
+        try:
+            # Ensure parent directory exists
+            config_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(config_file, "w", encoding="utf-8") as f:
+                json.dump(config, f, indent=2, ensure_ascii=False)
+            return True
+        except Exception as e:
+            print(f"Warning: Failed to save config for engine '{engine_id}': {e}")
+            return False
+
+    def update_engine_config(self, engine_id: str, updates: Dict[str, Any]) -> bool:
+        """
+        Update specific keys in an engine's configuration.
+        
+        Args:
+            engine_id: The engine identifier
+            updates: Dictionary containing the keys to update
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not isinstance(updates, dict):
+            print(f"Warning: Updates for engine '{engine_id}' must be a dictionary")
+            return False
+        
+        # Load existing config
+        config = self.load_engine_config(engine_id)
+        
+        # Update with new values
+        config.update(updates)
+        
+        # Save updated config
+        return self.save_engine_config(engine_id, config)
+
+    def delete_engine_config(self, engine_id: str) -> bool:
+        """
+        Delete configuration directory for a specific engine.
+        
+        Args:
+            engine_id: The engine identifier
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        engine_dir = self.get_engine_config_dir(engine_id)
+        if not engine_dir or not engine_dir.exists():
+            return False
+        
+        try:
+            import shutil
+            shutil.rmtree(engine_dir)
+            return True
+        except Exception as e:
+            print(f"Warning: Failed to delete config directory for engine '{engine_id}': {e}")
+            return False
+
+    def list_engine_configs(self) -> list[str]:
+        """
+        List all engine IDs that have configurations.
+        
+        Returns:
+            List of engine IDs with existing configurations
+        """
+        if not self._config_root or not self._config_root.exists():
+            return []
+        
+        try:
+            engine_ids = []
+            for item in self._config_root.iterdir():
+                if item.is_dir():
+                    engine_ids.append(item.name)
+            return sorted(engine_ids)
+        except Exception as e:
+            print(f"Warning: Failed to list engine configs: {e}")
+            return []
+
+    def get_config_root_path(self) -> Optional[Path]:
+        """
+        Get the root configuration directory path.
+        
+        Returns:
+            Path to ark_engines_config directory, or None if not available
+        """
+        return self._config_root
+
+    def engine_has_config(self, engine_id: str) -> bool:
+        """
+        Check if an engine has a configuration file.
+        
+        Args:
+            engine_id: The engine identifier
+            
+        Returns:
+            True if config file exists, False otherwise
+        """
+        config_file = self.get_engine_config_file(engine_id)
+        return config_file is not None and config_file.exists()
+
+
+# Global instance (lazy-loaded)
+_global_config_manager: Optional[EnginesConfigManager] = None
+
+
+def get_engines_config_manager(workspace_dir: Optional[str] = None) -> EnginesConfigManager:
+    """
+    Get or create the global engines config manager instance.
+    
+    Args:
+        workspace_dir: Workspace directory (required for first call)
+        
+    Returns:
+        EnginesConfigManager instance
+    """
+    global _global_config_manager
+    
+    if _global_config_manager is None:
+        if not workspace_dir:
+            raise ValueError("workspace_dir is required for first initialization")
+        _global_config_manager = EnginesConfigManager(workspace_dir)
+    
+    return _global_config_manager
+
+
+def reset_engines_config_manager() -> None:
+    """Reset the global config manager instance (useful for testing)."""
+    global _global_config_manager
+    _global_config_manager = None
+
+
+__all__ = [
+    "EnginesConfigManager",
+    "get_engines_config_manager",
+    "reset_engines_config_manager",
+]