correction de pyinstaller engie et aussi ajout duto save des config engine

Author: raidos23

AUTOSAVE_CONFIG_GUIDE.md

@@ -0,0 +1,388 @@
+# EngineConfigHelper - Auto-Save Configuration System
+
+## Overview
+
+The `EngineConfigHelper` now features **automatic configuration persistence**:
+
+- ✅ Auto-loads configuration on first access
+- ✅ Auto-saves configuration on every change
+- ✅ No manual save() calls needed
+- ✅ Simple, clean API
+- ✅ Persistent storage
+
+## How It Works
+
+### Auto-Load
+
+Configuration is automatically loaded from disk on first access:
+
+```python
+from engine_sdk import EngineConfigHelper
+
+class MyEngine(CompilerEngine):
+    def __init__(self):
+        self.config = EngineConfigHelper(self.id)
+    
+    def preflight(self, gui, file: str) -> bool:
+        # Configuration is auto-loaded on first access
+        timeout = self.config.get(gui, "timeout", default=30)
+        # ✅ Configuration loaded from disk automatically
+        return True
+```
+
+### Auto-Save
+
+Configuration is automatically saved to disk on every change:
+
+```python
+def preflight(self, gui, file: str) -> bool:
+    # Set value - automatically saved to disk
+    self.config.set(gui, "timeout", 60)
+    # ✅ Configuration saved to disk automatically
+    
+    # Update multiple values - automatically saved
+    self.config.update(gui, {"key1": "value1", "key2": "value2"})
+    # ✅ Configuration saved to disk automatically
+    
+    return True
+```
+
+## API Reference
+
+### get(gui, key, default=None)
+
+Get a configuration value. Auto-loads if needed.
+
+```python
+timeout = self.config.get(gui, "timeout", default=30)
+```
+
+### set(gui, key, value)
+
+Set a configuration value and auto-save.
+
+```python
+self.config.set(gui, "timeout", 60)
+# ✅ Automatically saved to disk
+```
+
+### update(gui, updates)
+
+Update multiple values and auto-save.
+
+```python
+self.config.update(gui, {
+    "timeout": 60,
+    "verbose": True,
+    "output_dir": "dist"
+})
+# ✅ Automatically saved to disk
+```
+
+### delete(gui, key)
+
+Delete a configuration value and auto-save.
+
+```python
+self.config.delete(gui, "old_key")
+# ✅ Automatically saved to disk
+```
+
+### clear(gui)
+
+Clear all configuration values and auto-save.
+
+```python
+self.config.clear(gui)
+# ✅ Automatically saved to disk
+```
+
+### load(gui)
+
+Explicitly load configuration from disk.
+
+```python
+config = self.config.load(gui)
+# Returns: {"timeout": 60, "verbose": True, ...}
+```
+
+### save(gui)
+
+Explicitly save configuration to disk.
+
+```python
+success = self.config.save(gui)
+# Returns: True if successful, False otherwise
+```
+
+### has_key(gui, key)
+
+Check if a configuration key exists.
+
+```python
+if self.config.has_key(gui, "timeout"):
+    print("Timeout is configured")
+```
+
+### keys(gui)
+
+Get all configuration keys.
+
+```python
+keys = self.config.keys(gui)
+# Returns: ["timeout", "verbose", "output_dir"]
+```
+
+### values(gui)
+
+Get all configuration values.
+
+```python
+values = self.config.values(gui)
+# Returns: [60, True, "dist"]
+```
+
+### items(gui)
+
+Get all configuration items.
+
+```python
+items = self.config.items(gui)
+# Returns: [("timeout", 60), ("verbose", True), ("output_dir", "dist")]
+```
+
+### reset(gui)
+
+Reset configuration to last saved state.
+
+```python
+self.config.reset(gui)
+# Reloads configuration from disk
+```
+
+### to_dict(gui)
+
+Get configuration as dictionary.
+
+```python
+config_dict = self.config.to_dict(gui)
+# Returns: {"timeout": 60, "verbose": True, ...}
+```
+
+## Storage Location
+
+Configurations are stored in:
+
+```
+workspace/ark_engines_config/<engine_id>/config.json
+```
+
+Example:
+
+```
+workspace/
+└── ark_engines_config/
+    ├── pyinstaller/
+    │   └── config.json
+    ├── nuitka/
+    │   └── config.json
+    └── cx_freeze/
+        └── config.json
+```
+
+## Configuration Format
+
+Each configuration is stored as JSON:
+
+```json
+{
+  "output_dir": "dist",
+  "one_file": false,
+  "console": true,
+  "timeout": 60,
+  "verbose": true,
+  "env_vars": {
+    "VAR1": "value1"
+  }
+}
+```
+
+## Complete Example
+
+```python
+from engine_sdk import (
+    CompilerEngine,
+    EngineConfigHelper,
+    safe_log,
+)
+
+class MyEngine(CompilerEngine):
+    id = "my_engine"
+    name = "My Engine"
+    version = "1.0.0"
+    required_core_version = "1.0.0"
+    required_sdk_version = "1.0.0"
+    
+    def __init__(self):
+        super().__init__()
+        self.config = EngineConfigHelper(self.id)
+    
+    def preflight(self, gui, file: str) -> bool:
+        try:
+            # Get configuration (auto-loads if needed)
+            timeout = self.config.get(gui, "timeout", default=30)
+            verbose = self.config.get(gui, "verbose", default=False)
+            
+            safe_log(gui, f"Timeout: {timeout}, Verbose: {verbose}")
+            
+            # Set configuration (auto-saves)
+            self.config.set(gui, "last_used", file)
+            
+            return True
+        except Exception as e:
+            safe_log(gui, f"Error: {e}")
+            return False
+    
+    def build_command(self, gui, file: str) -> list[str]:
+        try:
+            # Get configuration (auto-loads if needed)
+            output_dir = self.config.get(gui, "output_dir", default="dist")
+            optimization = self.config.get(gui, "optimization", default=0)
+            
+            cmd = ["my-compiler", file, "--output", output_dir]
+            
+            if optimization > 0:
+                cmd.extend(["--optimize", str(optimization)])
+            
+            return cmd
+        except Exception as e:
+            safe_log(gui, f"Error: {e}")
+            return []
+    
+    def create_tab(self, gui):
+        try:
+            from PySide6.QtWidgets import (
+                QWidget, QVBoxLayout, QHBoxLayout, QLabel,
+                QLineEdit, QSpinBox, QPushButton
+            )
+            
+            tab = QWidget()
+            layout = QVBoxLayout(tab)
+            
+            # Get configuration (auto-loads if needed)
+            output_dir = self.config.get(gui, "output_dir", default="dist")
+            optimization = self.config.get(gui, "optimization", default=0)
+            
+            # Output directory
+            row1 = QHBoxLayout()
+            row1.addWidget(QLabel("Output Directory:"))
+            output_edit = QLineEdit()
+            output_edit.setText(output_dir)
+            row1.addWidget(output_edit)
+            layout.addLayout(row1)
+            
+            # Optimization level
+            row2 = QHBoxLayout()
+            row2.addWidget(QLabel("Optimization:"))
+            opt_spin = QSpinBox()
+            opt_spin.setValue(optimization)
+            row2.addWidget(opt_spin)
+            layout.addLayout(row2)
+            
+            # Save button
+            save_btn = QPushButton("Save Configuration")
+            
+            def _save_config():
+                # Update configuration (auto-saves)
+                self.config.update(gui, {
+                    "output_dir": output_edit.text(),
+                    "optimization": opt_spin.value()
+                })
+                safe_log(gui, "✅ Configuration saved")
+            
+            save_btn.clicked.connect(_save_config)
+            layout.addWidget(save_btn)
+            layout.addStretch()
+            
+            return tab, "My Engine"
+        except Exception as e:
+            safe_log(gui, f"Error: {e}")
+            return None
+```
+
+## Benefits
+
+### For Users
+- ✅ Configuration persists automatically
+- ✅ No need to manually save
+- ✅ Settings are always up-to-date
+- ✅ Better user experience
+
+### For Developers
+- ✅ Simpler code
+- ✅ No manual save() calls
+- ✅ Automatic persistence
+- ✅ Less error-prone
+- ✅ Cleaner API
+
+### For the Project
+- ✅ Better architecture
+- ✅ Consistent behavior
+- ✅ Easier to maintain
+- ✅ Production-ready
+- ✅ Scalable design
+
+## Migration from Manual Save
+
+### Before (Manual Save)
+
+```python
+def preflight(self, gui, file: str) -> bool:
+    self.config.load(gui)
+    timeout = self.config.get(gui, "timeout", default=30)
+    self.config.set(gui, "timeout", 60)
+    self.config.save(gui)  # ❌ Manual save
+    return True
+```
+
+### After (Auto-Save)
+
+```python
+def preflight(self, gui, file: str) -> bool:
+    timeout = self.config.get(gui, "timeout", default=30)
+    self.config.set(gui, "timeout", 60)  # ✅ Auto-saves
+    return True
+```
+
+## Troubleshooting
+
+### Configuration not persisting
+
+1. Check that `gui.workspace_dir` is set
+2. Check that `ark_engines_config/` directory is writable
+3. Check that JSON serialization works for your values
+4. Run `verify_engines_loader.py` for diagnostics
+
+### Configuration not loading
+
+1. Check that configuration file exists
+2. Check that JSON is valid
+3. Check that `gui.workspace_dir` is correct
+4. Try calling `self.config.reset(gui)` to reload
+
+### Performance issues
+
+- Auto-save happens on every change
+- For bulk updates, use `update()` instead of multiple `set()` calls
+- Example: `self.config.update(gui, {key1: val1, key2: val2})`
+
+## Summary
+
+The new auto-save system provides:
+- ✅ Automatic configuration persistence
+- ✅ Simple, clean API
+- ✅ No manual save() calls needed
+- ✅ Better user experience
+- ✅ Production-ready
+
+Use it in all new engines!