style: formatage et nettoyage des imports dans le répertoire Ui

Author: raidos23

Ui/Cli/__init__.py

@@ -4,4 +4,3 @@
 from .entrypoint import main
 
 __all__ = ["build_cli", "has_click", "main"]
-

Ui/Cli/app.py

@@ -5,8 +5,6 @@
 from pathlib import Path
 from typing import Any
 
-from .runtime import install_runtime, should_enable_qt
-
 from .helpers import (
     CliSpecError,
     build_context_object_from_ark_config,
@@ -32,6 +30,7 @@
     validate_ark_config,
     write_lock_files,
 )
+from .runtime import install_runtime, should_enable_qt
 
 try:
     import click  # type: ignore
@@ -88,6 +87,7 @@ def _build_impl(
 
     # 1. BCASL Pre-compile check (Point 1 of mutation plan)
     from .helpers import run_bcasl_before_compile_sync
+
     if not run_bcasl_before_compile_sync(workspace):
         return 1
 
@@ -97,7 +97,9 @@ def _build_impl(
         engine_id = engine_override or str(validated.config["build"]["engine"])
         _ensure_engine_known(engine_id)
         # Point 3 alignment: build_lock_payload now correctly loads engine config via fixed path
-        lock_payload = build_lock_payload(workspace, validated.config, engine_id=engine_id)
+        lock_payload = build_lock_payload(
+            workspace, validated.config, engine_id=engine_id
+        )
         lock_paths = write_lock_files(workspace, lock_payload)
         context = build_context_object_from_ark_config(validated.config)
         result = run_engine_compile(
@@ -162,7 +164,9 @@ def _build_impl(
         current_config = load_ark_config(workspace)
         validated = validate_ark_config(workspace, current_config)
         regenerated = build_lock_payload(
-            workspace, validated.config, engine_id=str(validated.config["build"]["engine"])
+            workspace,
+            validated.config,
+            engine_id=str(validated.config["build"]["engine"]),
         )
         rebuild_cache = cache_rebuild_lock(workspace, regenerated)
         comparison = compare_lock_payloads(lock_payload, regenerated)
@@ -212,7 +216,9 @@ def cli():
     @click.option("--install-requirements", is_flag=True)
     @click.option("--generate-requirements", is_flag=True)
     @click.option("--json", "as_json", is_flag=True)
-    def init_cmd(entry, icon, with_venv, install_requirements, generate_requirements, as_json):
+    def init_cmd(
+        entry, icon, with_venv, install_requirements, generate_requirements, as_json
+    ):
         """Initialize the current directory as an ARK workspace."""
         try:
             payload = init_workspace(
@@ -249,7 +255,9 @@ def init_cmd(entry, icon, with_venv, install_requirements, generate_requirements
     @click.option("--json", "as_json", is_flag=True)
     def build_cmd(engine_override, lock_file, lock_arg, as_json):
         """Build from ark.yml or rebuild from a lock file."""
-        effective_lock = lock_arg if lock_arg and lock_file == "__default__" else lock_file
+        effective_lock = (
+            lock_arg if lock_arg and lock_file == "__default__" else lock_file
+        )
         try:
             code = _build_impl(
                 workspace=Path.cwd(),
@@ -309,6 +317,7 @@ def unset_group():
         "dev-engine-dir",
         "dev-plugin-dir",
     ):
+
         def _make_set(spec_key: str):
             @set_group.command(spec_key)
             @click.argument("path")
@@ -369,7 +378,9 @@ def scaffold_engine_cmd(name, root_dir, as_json):
             _echo_json(payload)
             return
         if not payload.get("created"):
-            raise click.ClickException(payload.get("reason", "Unable to create scaffold"))
+            raise click.ClickException(
+                payload.get("reason", "Unable to create scaffold")
+            )
         click.echo(payload["path"])
 
     @scaffold_group.command("plugin-bcasl")
@@ -382,7 +393,9 @@ def scaffold_plugin_cmd(name, root_dir, as_json):
             _echo_json(payload)
             return
         if not payload.get("created"):
-            raise click.ClickException(payload.get("reason", "Unable to create scaffold"))
+            raise click.ClickException(
+                payload.get("reason", "Unable to create scaffold")
+            )
         click.echo(payload["path"])
 
     return cli

Ui/Cli/discovery.py

@@ -249,7 +249,7 @@ def scaffold_engine(target_name: str, root_dir: str | None = None) -> dict[str,
                 "",
                 "@engine_register",
                 f"class {safe.title().replace('_', '')}Engine(CompilerEngine):",
-                f'    id = \"{safe}\"',
+                f'    id = "{safe}"',
                 f"    name = \"{safe.title().replace('_', ' ')}\"",
                 '    version = "0.1.0"',
                 '    required_core_version = "1.0.0"',

Ui/Cli/helpers.py

@@ -7,38 +7,36 @@
 from pathlib import Path
 from typing import Any
 
-from Core.Configs import (
-    ArkConfigError,
-    ArkConfigValidationResult,
-    load_ark_config as _load_ark_config,
-    new_workspace_config,
-    validate_ark_config as _validate_ark_config,
-    write_ark_config,
-)
-from Core.Locking import (
-    BuildContext,
-    build_context_from_ark_config as _build_context_from_ark_config,
-    build_context_from_lock as _build_context_from_lock,
-    build_lock_payload as _build_lock_payload,
-    cache_rebuild_lock as _cache_rebuild_lock,
-    compare_lock_payloads as _compare_lock_payloads,
-    default_lock_path as _default_lock_path,
-    ensure_workspace_layout,
-    load_yaml_file,
-    write_lock_files as _write_lock_files,
-)
 from Core.Compiler.engine_runner import run_engine_compile as _core_run_engine_compile
 from Core.Configs import (
     CONFIG_KEYS,
     DEFAULT_USER_DIRS,
+    ArkConfigError,
+    ArkConfigValidationResult,
     UserConfigError,
-    config_home as _config_home,
-    ensure_config_home as _ensure_config_home,
-    config_file_for as _config_file_for,
+)
+from Core.Configs import config_file_for as _config_file_for
+from Core.Configs import config_home as _config_home
+from Core.Configs import ensure_config_home as _ensure_config_home
+from Core.Configs import load_ark_config as _load_ark_config
+from Core.Configs import (
+    new_workspace_config,
     resolve_config_value,
     set_config_value,
     unset_config_value,
 )
+from Core.Configs import validate_ark_config as _validate_ark_config
+from Core.Configs import write_ark_config
+from Core.Locking import BuildContext
+from Core.Locking import build_context_from_ark_config as _build_context_from_ark_config
+from Core.Locking import build_context_from_lock as _build_context_from_lock
+from Core.Locking import build_lock_payload as _build_lock_payload
+from Core.Locking import cache_rebuild_lock as _cache_rebuild_lock
+from Core.Locking import compare_lock_payloads as _compare_lock_payloads
+from Core.Locking import default_lock_path as _default_lock_path
+from Core.Locking import ensure_workspace_layout, load_yaml_file
+from Core.Locking import write_lock_files as _write_lock_files
+
 from .discovery import (
     bcasl_list_payload,
     engine_info_payload,
@@ -63,6 +61,7 @@ class ArkValidationResult:
 # resolve_config_value / set_config_value / unset_config_value are imported
 # directly from Core.Configs above and re-exported as-is.
 
+
 def config_home() -> Path:
     """Return the ARK user config root (delegates to Core.Configs)."""
     return _config_home()
@@ -162,7 +161,9 @@ def init_workspace(
             text=True,
         )
         if result.returncode != 0:
-            raise CliSpecError(result.stderr.strip() or "requirements installation failed")
+            raise CliSpecError(
+                result.stderr.strip() or "requirements installation failed"
+            )
 
     return {
         "workspace": str(workspace),
@@ -204,7 +205,12 @@ def validate_ark_config(workspace: Path, config: dict[str, Any]) -> ArkValidatio
 def engine_version(engine_id: str) -> str:
     try:
         payload = engine_info_payload(engine_id)
-        return str(((payload.get("engine") or {}) if payload.get("found") else {}).get("version") or "unknown")
+        return str(
+            ((payload.get("engine") or {}) if payload.get("found") else {}).get(
+                "version"
+            )
+            or "unknown"
+        )
     except Exception:
         return "unknown"
 
@@ -301,16 +307,19 @@ def run_bcasl_before_compile_sync(workspace: Path) -> bool:
     Returns:
         True if compilation can proceed (success or BCASL disabled), False otherwise.
     """
-    from .output import info, error, success, log
     from bcasl.Loader import run_pre_compile
 
+    from .output import error, info, log, success
+
     class CliBcaslHost:
         def __init__(self, ws_dir: Path):
             self.workspace_dir = str(ws_dir)
+
             class Logger:
                 def append(self, msg: str):
                     # Strip trailing newline as our log() adds one
                     log("BCASL", msg.rstrip())
+
             self.log = Logger()
 
     host = CliBcaslHost(workspace)
@@ -337,25 +346,28 @@ def append(self, msg: str):
 
 def run_bcasl_headless(args: list[str]) -> int:
     """Run BCASL in headless mode for the current workspace."""
-    from .output import error, success
     from bcasl.Loader import run_pre_compile
 
+    from .output import error, success
+
     workspace = Path.cwd()
     if "run" in args:
         # If workspace path is provided in args, use it
         for i, arg in enumerate(args):
             if arg == "run" and i + 1 < len(args):
-                candidate = Path(args[i+1])
+                candidate = Path(args[i + 1])
                 if candidate.is_dir():
                     workspace = candidate.resolve()
                 break
 
     class CliBcaslHost:
         def __init__(self, ws_dir: Path):
             self.workspace_dir = str(ws_dir)
+
             class Logger:
                 def append(self, msg: str):
                     print(msg, end="", flush=True)
+
             self.log = Logger()
 
     host = CliBcaslHost(workspace)
@@ -370,6 +382,7 @@ def append(self, msg: str):
         error(f"BCASL failed: {exc}")
         return 1
 
+
 def launch_gui(*, legacy: bool = False) -> int:
     return launch_main_application(
         no_splash=False,

Ui/Cli/icons.py

@@ -36,4 +36,3 @@ def set_window_icon(target) -> None:
             target.setWindowIcon(QIcon(icon_path))
     except Exception:
         pass
-

Ui/Cli/launchers.py

@@ -57,11 +57,12 @@ def launch_main_application(
     no_splash: bool = False, ide_gui: bool = False, classic_gui: bool = False
 ) -> int:
     try:
-        from Ui.Gui.Gui import PyCompilerArkGui
         from PySide6.QtCore import Qt, QTimer
         from PySide6.QtGui import QColor, QPixmap
         from PySide6.QtWidgets import QSplashScreen
 
+        from Ui.Gui.Gui import PyCompilerArkGui
+
         app = _get_or_create_qapp()
         set_app_icon(app)
         app_version = _get_app_version()
@@ -88,24 +89,27 @@ def launch_main_application(
                             screen = app.primaryScreen()
                             if screen:
                                 sgeo = screen.availableGeometry()
-                                max_w, max_h = int(sgeo.width() * 0.5), int(sgeo.height() * 0.5)
+                                max_w, max_h = int(sgeo.width() * 0.5), int(
+                                    sgeo.height() * 0.5
+                                )
                                 if pix.width() > max_w or pix.height() > max_h:
                                     pix = pix.scaled(
-                                        max_w, max_h,
+                                        max_w,
+                                        max_h,
                                         Qt.KeepAspectRatio,
-                                        Qt.SmoothTransformation
+                                        Qt.SmoothTransformation,
                                     )
 
                             splash = QSplashScreen(pix, Qt.WindowStaysOnTopHint)
-                            
+
                             # Centrage explicite
                             if screen:
                                 sgeo = screen.availableGeometry()
                                 splash.move(
                                     sgeo.x() + (sgeo.width() - pix.width()) // 2,
-                                    sgeo.y() + (sgeo.height() - pix.height()) // 2
+                                    sgeo.y() + (sgeo.height() - pix.height()) // 2,
                                 )
-                            
+
                             splash.show()
                             app.processEvents()
                         break
@@ -151,4 +155,3 @@ def _launch_main():
     except Exception as exc:
         error(f"Failed to launch main application: {exc}")
         return 1
-

Ui/Cli/output.py

@@ -60,4 +60,3 @@ def error(message: str) -> None:
 
 def success(message: str) -> None:
     log("SUCCESS", message, err=False)
-

Ui/Cli/runtime.py

@@ -246,4 +246,3 @@ def install_runtime(app_version: str, enable_qt: bool = True) -> None:
         install_qt_metadata(app_version)
         install_qt_handlers()
     install_signal_handlers()
-