retirement du engine loder connetion avec ark config

Author: raidos23

Core/ark_config_loader.py

@@ -54,32 +54,6 @@
     "compile_only_main": False,
     "main_file_names": ["main.py", "app.py"],
     "auto_detect_entry_points": True,
-    # PyInstaller options
-    "pyinstaller": {
-        "onefile": True,
-        "windowed": False,
-        "noconfirm": True,
-        "clean": False,
-        "noupx": False,
-        "icon": None,
-        "debug": False,
-        "additional_options": [],
-    },
-    # Nuitka options
-    "nuitka": {
-        "onefile": True,
-        "standalone": True,
-        "disable_console": False,
-        "show_progress": True,
-        "output_dir": None,
-        "icon": None,
-        "additional_options": [],
-    },
-    # Output configuration
-    "output": {
-        "directory": "dist",
-        "clean_before_build": False,
-    },
     # Dependencies
     "dependencies": {
         "requirements_files": [
@@ -108,11 +82,6 @@
         "bcasl_enabled": True,
         "plugin_timeout": 0.0,
     },
-    # Engines UI state (persisted widget states per engine)
-    "engines": {
-        "pyinstaller": {"ui": {"widgets": {}}},
-        "nuitka": {"ui": {"widgets": {}}},
-    },
 }
 
 
@@ -321,27 +290,6 @@ def create_default_ark_config(workspace_dir: str) -> bool:
   - "app.py"
 auto_detect_entry_points: true
 
-# PYINSTALLER OPTIONS
-pyinstaller:
-  onefile: true
-  windowed: false
-  noconfirm: true
-  clean: false
-  noupx: false
-  icon: null
-  debug: false
-  additional_options: []
-
-# NUITKA OPTIONS
-nuitka:
-  onefile: true
-  standalone: true
-  disable_console: false
-  show_progress: true
-  output_dir: null
-  icon: null
-  additional_options: []
-
 # OUTPUT CONFIGURATION
 output:
   directory: "dist"
@@ -362,15 +310,6 @@ def create_default_ark_config(workspace_dir: str) -> bool:
     - "pip"
   auto_detect: true
   fallback_to_pip: true
-
-# ENGINES (UI state persistence)
-engines:
-  pyinstaller:
-    ui:
-      widgets: {}
-  nuitka:
-    ui:
-      widgets: {}
 """
 
         with open(config_file, "w", encoding="utf-8") as f:
@@ -383,142 +322,3 @@ def create_default_ark_config(workspace_dir: str) -> bool:
         return False
 
 
-# --- Simple Engine UI state helpers (for non-dev friendly persistence) ---
-
-
-def _read_yaml(path: Path) -> dict:
-    try:
-        if path.exists():
-            with open(path, "r", encoding="utf-8") as f:
-                data = yaml.safe_load(f) or {}
-                return data if isinstance(data, dict) else {}
-    except Exception:
-        pass
-    return {}
-
-
-def _write_yaml_atomic(path: Path, data: dict) -> bool:
-    try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = path.with_suffix(path.suffix + ".tmp")
-        with open(tmp, "w", encoding="utf-8") as f:
-            yaml.safe_dump(data, f, allow_unicode=True, sort_keys=False)
-        os.replace(tmp, path)
-        return True
-    except Exception:
-        return False
-
-
-essential_props = ("checked", "text", "enabled", "visible", "currentIndex")
-
-
-def load_engine_ui_state(workspace_dir: str, engine_id: str) -> dict:
-    """Load saved UI state for an engine from ARK_Main_Config.yml (YAML ONLY).
-    Cherche les fichiers dans cet ordre:
-    1. ARK_Main_Config.yaml
-    2. ARK_Main_Config.yml
-    3. .ARK_Main_Config.yaml
-    4. .ARK_Main_Config.yml
-
-    Returns a mapping {widgetName: {prop: value}} or {}.
-    """
-    try:
-        if not workspace_dir:
-            return {}
-
-        workspace_path = Path(workspace_dir)
-
-        # Chercher les fichiers YAML dans l'ordre de priorité
-        config_candidates = [
-            workspace_path / "ARK_Main_Config.yaml",
-            workspace_path / "ARK_Main_Config.yml",
-            workspace_path / ".ARK_Main_Config.yaml",
-            workspace_path / ".ARK_Main_Config.yml",
-        ]
-
-        cfg = {}
-        for candidate in config_candidates:
-            if candidate.exists() and candidate.is_file():
-                cfg = _read_yaml(candidate)
-                break
-
-        engines = cfg.get("engines", {}) if isinstance(cfg, dict) else {}
-        e = engines.get(str(engine_id), {}) if isinstance(engines, dict) else {}
-        ui = e.get("ui", {}) if isinstance(e, dict) else {}
-        widgets = ui.get("widgets", {}) if isinstance(ui, dict) else {}
-        return widgets if isinstance(widgets, dict) else {}
-    except Exception:
-        return {}
-
-
-def save_engine_ui_state(workspace_dir: str, engine_id: str, updates: dict) -> bool:
-    """Save UI state for an engine into ARK_Main_Config.yml (YAML ONLY).
-    Cherche les fichiers existants dans cet ordre:
-    1. ARK_Main_Config.yaml
-    2. ARK_Main_Config.yml
-    3. .ARK_Main_Config.yaml
-    4. .ARK_Main_Config.yml
-
-    Si aucun fichier n'existe, crée ARK_Main_Config.yml par défaut.
-
-    - workspace_dir: project workspace path
-    - engine_id: id string (e.g. 'pyinstaller')
-    - updates: {widgetName: {prop: value}}
-    Returns True on success, False otherwise.
-    """
-    if not workspace_dir:
-        return False
-    try:
-        workspace_path = Path(workspace_dir)
-
-        # Chercher les fichiers YAML existants dans l'ordre de priorité
-        config_candidates = [
-            workspace_path / "ARK_Main_Config.yaml",
-            workspace_path / "ARK_Main_Config.yml",
-            workspace_path / ".ARK_Main_Config.yaml",
-            workspace_path / ".ARK_Main_Config.yml",
-        ]
-
-        cfg_path = None
-        for candidate in config_candidates:
-            if candidate.exists() and candidate.is_file():
-                cfg_path = candidate
-                break
-
-        # Si aucun fichier n'existe, utiliser ARK_Main_Config.yml par défaut
-        if cfg_path is None:
-            cfg_path = workspace_path / "ARK_Main_Config.yml"
-
-        cfg = _read_yaml(cfg_path)
-        if not isinstance(cfg, dict):
-            cfg = {}
-        engines = cfg.get("engines")
-        if not isinstance(engines, dict):
-            engines = {}
-            cfg["engines"] = engines
-        e = engines.get(str(engine_id))
-        if not isinstance(e, dict):
-            e = {}
-            engines[str(engine_id)] = e
-        ui = e.get("ui")
-        if not isinstance(ui, dict):
-            ui = {}
-            e["ui"] = ui
-        widgets = ui.get("widgets")
-        if not isinstance(widgets, dict):
-            widgets = {}
-            ui["widgets"] = widgets
-        # Merge per widget
-        for wname, props in (updates or {}).items():
-            if not isinstance(wname, str) or not isinstance(props, dict):
-                continue
-            cur = widgets.get(wname)
-            if not isinstance(cur, dict):
-                cur = {}
-                widgets[wname] = cur
-            for k, v in props.items():
-                if k in essential_props:
-                    cur[k] = v
-        return _write_yaml_atomic(cfg_path, cfg)
-    except Exception:
-        return False

Core/engines_loader/registry.py

@@ -18,7 +18,6 @@
 from typing import Optional, Any
 
 from .base import CompilerEngine
-from Core.ark_config_loader import load_engine_ui_state, save_engine_ui_state
 
 _REGISTRY: dict[str, type[CompilerEngine]] = {}
 _ORDER: list[str] = []
@@ -64,49 +63,6 @@ def register(engine_cls: type[CompilerEngine]):
         return engine_cls
 
 
-def _apply_widgets_state(container, widgets_state: dict) -> None:
-    """Apply basic properties to child widgets given a simple state mapping.
-    Supported props: checked, text, enabled, visible, currentIndex.
-    """
-    try:
-        for wname, props in widgets_state.items():
-            try:
-                w = container.findChild(object, wname)
-                if w is None:
-                    continue
-                for k, v in (props or {}).items():
-                    try:
-                        if k == "checked" and hasattr(w, "setChecked"):
-                            w.setChecked(bool(v))
-                        elif k == "text" and hasattr(w, "setText"):
-                            w.setText(str(v))
-                        elif k == "enabled" and hasattr(w, "setEnabled"):
-                            w.setEnabled(bool(v))
-                        elif k == "visible" and hasattr(w, "setVisible"):
-                            w.setVisible(bool(v))
-                        elif k == "currentIndex" and hasattr(w, "setCurrentIndex"):
-                            w.setCurrentIndex(int(v))
-                    except Exception:
-                        continue
-            except Exception:
-                continue
-    except Exception:
-        pass
-
-
-def save_engine_ui(gui, engine_id: str, updates: dict[str, dict[str, Any]]) -> bool:
-    """Public helper for engines to persist UI state into ARK_Main_Config.yml.
-    Engines pass a mapping {widgetName: {prop: value}}. Returns True on success.
-    """
-    try:
-        ws = getattr(gui, "workspace_dir", None)
-        if not ws:
-            return False
-        return save_engine_ui_state(ws, engine_id, updates)
-    except Exception:
-        return False
-
-
 def get_engine(eid: str) -> Optional[type[CompilerEngine]]:
     try:
         return _REGISTRY.get(eid)
@@ -141,15 +97,6 @@ def bind_tabs(gui) -> None:
                 if not pair:
                     continue
                 widget, label = pair
-                # Apply saved UI state for this engine (simple mapping by objectName)
-                try:
-                    ws = getattr(gui, "workspace_dir", None)
-                    if ws:
-                        widgets_state = load_engine_ui_state(ws, eid)
-                        if isinstance(widgets_state, dict) and widgets_state:
-                            _apply_widgets_state(widget, widgets_state)
-                except Exception:
-                    pass
                 try:
                     existing = tabs.indexOf(widget)
                 except Exception: