Finalisation du todo: branche Git dans le locking, version Python précise, i18n stats et amélioration ergonomie UI

Author: raidos23

Core/Compiler/utils.py

@@ -443,6 +443,20 @@ def get_interpreter_version(python_path: Optional[str] = None) -> Tuple[int, int
     return sys.version_info.major, sys.version_info.minor, sys.version_info.micro
 
 
+def get_interpreter_version_str(python_path: Optional[str] = None) -> str:
+    """
+    Return Python interpreter version as a string.
+
+    Args:
+     python_path: Path de l'interpréteur (défaut: sys.executable)
+
+    Returns:
+     Version string (ex: "3.10.12")
+    """
+    v = get_interpreter_version(python_path)
+    return f"{v[0]}.{v[1]}.{v[2]}"
+
+
 def check_module_available(module_name: str, python_path: Optional[str] = None) -> bool:
     """
     Check whether a Python module is available.

Core/Locking/__init__.py

@@ -133,6 +133,23 @@ def get_git_commit_hash(workspace: Path) -> str | None:
         return None
 
 
+def get_git_branch(workspace: Path) -> str | None:
+    """Return the current Git branch of the workspace if available."""
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=str(workspace),
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=True
+        )
+        return result.stdout.strip()
+    except Exception:
+        return None
+
+
 def next_build_id(lock_dir: Path) -> str:
     from datetime import UTC
     today = datetime.now(UTC).strftime("%Y_%m_%d")
@@ -153,6 +170,7 @@ def build_lock_payload(
     engine_id: str,
     engine_version: str = "unknown",
     dependencies: dict[str, str] | None = None,
+    python_version: str | None = None,
 ) -> dict[str, Any]:
     config = normalize_ark_config(config)
     build = config.get("build") or {}
@@ -162,6 +180,7 @@ def build_lock_payload(
     lock_dir = workspace / ".ark" / "lock"
     build_id = next_build_id(lock_dir)
     git_commit = get_git_commit_hash(workspace)
+    git_branch = get_git_branch(workspace)
 
     return {
         "build_id": build_id,
@@ -170,6 +189,7 @@ def build_lock_payload(
             "version": project.get("version"),
             "entry": project.get("entry"),
             "git_commit": git_commit,
+            "git_branch": git_branch,
         },
         "workspace": {"exclude_patterns": exclude_patterns},
         "build": {
@@ -186,7 +206,7 @@ def build_lock_payload(
         "platform": {
             "os": sys.platform,
             "arch": platform.machine(),
-            "python_version": platform.python_version(),
+            "python_version": python_version or platform.python_version(),
         },
         "dependencies": dependencies or installed_distributions_snapshot(),
         "workspace_hash": compute_workspace_hash(workspace, exclude_patterns),
@@ -275,6 +295,8 @@ def build_context_from_lock(lock_payload: dict[str, Any]) -> BuildContext:
     "default_lock_path",
     "engine_config_path",
     "ensure_workspace_layout",
+    "get_git_branch",
+    "get_git_commit_hash",
     "included_workspace_files",
     "installed_distributions_snapshot",
     "load_yaml_file",

Ui/Cli/app.py

@@ -90,6 +90,26 @@ def _build_impl(
     if not as_json and verbose:
         info(f"Workspace: {workspace}")
 
+    # Shared Python version resolution for locking/comparison
+    python_version = None
+    try:
+        from Core.Compiler.utils import get_interpreter_version_str
+        from Core.Venv_Manager.Manager import VenvManager
+        # We create a dummy bridge for VenvManager
+        class DummyBridge:
+            def __init__(self, ws):
+                self.workspace_dir = ws
+                self.use_system_python = False
+        vm = VenvManager(DummyBridge(str(workspace)))
+        vpython = vm.resolve_existing_venv()
+        if vpython:
+            vpath = vm.python_path(vpython)
+            python_version = get_interpreter_version_str(vpath)
+        else:
+            python_version = get_interpreter_version_str()
+    except Exception:
+        pass
+
     if lock_file is None:
         if not as_json and verbose:
             info("Loading ark.yml...")
@@ -102,9 +122,13 @@ def _build_impl(
 
         if not as_json and verbose:
             info(f"Generating lock payload for engine '{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
+            workspace,
+            validated.config,
+            engine_id=engine_id,
+            python_version=python_version,
         )
         if not as_json and verbose:
             info("Writing lock files...")
@@ -204,6 +228,7 @@ def _build_impl(
             workspace,
             validated.config,
             engine_id=str(validated.config["build"]["engine"]),
+            python_version=python_version,
         )
         rebuild_cache = cache_rebuild_lock(workspace, regenerated)
         comparison = compare_lock_payloads(lock_payload, regenerated)

Ui/Cli/helpers.py

@@ -354,12 +354,14 @@ def build_lock_payload(
     config: dict[str, Any],
     *,
     engine_id: str,
+    python_version: str | None = None,
 ) -> dict[str, Any]:
     return _build_lock_payload(
         workspace,
         config,
         engine_id=engine_id,
         engine_version=engine_version(engine_id),
+        python_version=python_version,
     )
 
 
@@ -407,15 +409,22 @@ def engine_config_from_lock(lock_payload: dict[str, Any]) -> dict[str, Any]:
 
 
 def ensure_correct_git_commit(workspace: Path, lock_payload: dict[str, Any]) -> bool:
-    """Vérifie si le commit Git actuel correspond à celui du verrou."""
-    locked_commit = ((lock_payload.get("project") or {}).get("git_commit"))
-    if not locked_commit:
+    """Vérifie si le commit et la branche Git actuels correspondent à ceux du verrou."""
+    project = lock_payload.get("project") or {}
+    locked_commit = project.get("git_commit")
+    locked_branch = project.get("git_branch")
+    
+    if not locked_commit and not locked_branch:
         return True
 
-    from Core.Locking import get_git_commit_hash
+    from Core.Locking import get_git_commit_hash, get_git_branch
     current_commit = get_git_commit_hash(workspace)
+    current_branch = get_git_branch(workspace)
+
+    commit_match = (not locked_commit) or (current_commit == locked_commit)
+    branch_match = (not locked_branch) or (current_branch == locked_branch)
 
-    if not current_commit or current_commit == locked_commit:
+    if commit_match and branch_match:
         return True
 
     from .output import warn, info, error, success
@@ -425,26 +434,46 @@ def ensure_correct_git_commit(workspace: Path, lock_payload: dict[str, Any]) ->
     is_linux = platform.system().lower() == "linux"
 
     warn(f"Mismatch Git détecté.")
-    info(f" - Verrou : {locked_commit[:8]}")
-    info(f" - Actuel : {current_commit[:8]}")
+    if not branch_match:
+        info(f" - Branche Verrou : {locked_branch}")
+        info(f" - Branche Actuelle : {current_branch}")
+    if not commit_match:
+        info(f" - Commit Verrou : {locked_commit[:8] if locked_commit else 'N/A'}")
+        info(f" - Commit Actuel : {current_commit[:8] if current_commit else 'N/A'}")
 
     if is_linux:
         try:
             import click
-            if click.confirm(f"Effectuer un 'git checkout {locked_commit[:8]}' automatique ?", default=True):
-                info(f"Alignement Git en cours...")
-                subprocess.run(["git", "checkout", locked_commit], cwd=str(workspace), check=True)
+            if not branch_match and locked_branch:
+                 if click.confirm(f"Effectuer un 'git checkout {locked_branch}' automatique ?", default=True):
+                    info(f"Changement de branche en cours...")
+                    subprocess.run(["git", "checkout", locked_branch], cwd=str(workspace), check=True)
+                    # Re-verify commit after branch change
+                    current_commit = get_git_commit_hash(workspace)
+                    commit_match = (not locked_commit) or (current_commit == locked_commit)
+            
+            if not commit_match and locked_commit:
+                if click.confirm(f"Effectuer un 'git checkout {locked_commit[:8]}' automatique ?", default=True):
+                    info(f"Alignement du commit en cours...")
+                    subprocess.run(["git", "checkout", locked_commit], cwd=str(workspace), check=True)
+                    success("Workspace aligné.")
+                    return True
+            
+            if commit_match and branch_match:
                 success("Workspace aligné.")
                 return True
             else:
                 warn("Build avec mismatch (non recommandé).")
                 return True
         except Exception as e:
-            error(f"Échec checkout : {e}")
+            error(f"Échec alignement Git : {e}")
             return False
     else:
-        warn("Checkout automatique non supporté sur cette plateforme.")
-        info(f"Action manuelle requise : git checkout {locked_commit}")
+        warn("Alignement automatique non supporté sur cette plateforme.")
+        if not branch_match and locked_branch:
+            info(f"Action manuelle requise : git checkout {locked_branch}")
+        if not commit_match and locked_commit:
+            info(f"Action manuelle requise : git checkout {locked_commit}")
         try:
             import click
             return click.confirm("Continuer quand même ?", default=False)

Ui/Gui/Dialogs/CompilerDialog.py

@@ -235,8 +235,27 @@ def _t(fr: str, en: str) -> str:
             "🔒 Génération du verrou de compilation (lock file)...",
             "🔒 Generating build lock file...",
         )
+        
+        # Resolve Python version for locking
+        python_version = None
+        try:
+            from Core.Compiler.utils import get_interpreter_version_str
+            from Core.Venv_Manager.Manager import VenvManager
+            vm = VenvManager(self)
+            vpython = vm.resolve_project_venv()
+            if vpython:
+                vpath = vm.python_path(vpython)
+                python_version = get_interpreter_version_str(vpath)
+            else:
+                python_version = get_interpreter_version_str()
+        except Exception:
+            pass
+
         lock_payload = build_lock_payload(
-            Path(self.workspace_dir), validated.config, engine_id=engine_id
+            Path(self.workspace_dir),
+            validated.config,
+            engine_id=engine_id,
+            python_version=python_version,
         )
         write_lock_files(Path(self.workspace_dir), lock_payload)
 

Ui/Gui/Dialogs/LockDialog.py

@@ -164,46 +164,75 @@ def _do_rebuild(self):
             QMessageBox.critical(self, "Error", "rebuild_from_lock method not implemented in GUI")
 
     def _ensure_git_alignment(self, lock_payload: dict) -> bool:
-        locked_commit = (lock_payload.get("project") or {}).get("git_commit")
-        if not locked_commit:
+        project = lock_payload.get("project") or {}
+        locked_commit = project.get("git_commit")
+        locked_branch = project.get("git_branch")
+        
+        if not locked_commit and not locked_branch:
             return True
 
-        from Core.Locking import get_git_commit_hash
+        from Core.Locking import get_git_commit_hash, get_git_branch
         ws = getattr(self.gui, "workspace_dir", None)
         if not ws:
             return True
 
         current_commit = get_git_commit_hash(Path(ws))
-        if not current_commit or current_commit == locked_commit:
+        current_branch = get_git_branch(Path(ws))
+
+        commit_match = (not locked_commit) or (current_commit == locked_commit)
+        branch_match = (not locked_branch) or (current_branch == locked_branch)
+
+        if commit_match and branch_match:
             return True
 
         import platform
         import subprocess
         is_linux = platform.system().lower() == "linux"
 
+        lines = []
+        if not branch_match:
+            lines.append(self.gui.tr(
+                f"Branche : actuelle={current_branch}, verrou={locked_branch}",
+                f"Branch: current={current_branch}, lock={locked_branch}"
+            ))
+        if not commit_match:
+            lines.append(self.gui.tr(
+                f"Commit : actuel={current_commit[:8] if current_commit else 'N/A'}, verrou={locked_commit[:8] if locked_commit else 'N/A'}",
+                f"Commit: current={current_commit[:8] if current_commit else 'N/A'}, lock={locked_commit[:8] if locked_commit else 'N/A'}"
+            ))
+
         msg = self.gui.tr(
-            f"Le commit Git actuel ({current_commit[:8]}) ne correspond pas à celui du verrou ({locked_commit[:8]}).\n\n",
-            f"Current Git commit ({current_commit[:8]}) does not match lock file ({locked_commit[:8]}).\n\n"
-        )
+            "Désalignement Git détecté :\n",
+            "Git mismatch detected:\n"
+        ) + "\n".join(lines) + "\n\n"
 
         if is_linux:
             msg += self.gui.tr(
-                "Voulez-vous que ARK effectue un 'git checkout' automatique pour aligner le code ?",
-                "Do you want ARK to perform an automatic 'git checkout' to align the code?"
+                "Voulez-vous que ARK tente d'aligner automatiquement le code (git checkout) ?",
+                "Do you want ARK to attempt automatic code alignment (git checkout)?"
             )
             ans = QMessageBox.question(self, "Git Mismatch", msg, QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
             if ans == QMessageBox.Yes:
                 try:
-                    subprocess.run(["git", "checkout", locked_commit], cwd=ws, check=True)
+                    if not branch_match and locked_branch:
+                        subprocess.run(["git", "checkout", locked_branch], cwd=ws, check=True)
+                    if not commit_match and locked_commit:
+                        subprocess.run(["git", "checkout", locked_commit], cwd=ws, check=True)
                     return True
                 except Exception as e:
-                    QMessageBox.critical(self, "Error", f"Échec du checkout : {e}")
+                    QMessageBox.critical(self, "Error", f"Échec de l'alignement : {e}")
                     return False
             return ans == QMessageBox.No # True si l'user ignore, False si Cancel
         else:
+            cmd_hint = ""
+            if not branch_match and locked_branch:
+                cmd_hint += f"git checkout {locked_branch}\n"
+            if not commit_match and locked_commit:
+                cmd_hint += f"git checkout {locked_commit[:8]}\n"
+
             msg += self.gui.tr(
-                f"Action recommandée : exécutez 'git checkout {locked_commit}' manuellement avant de continuer.\n\nContinuer le build quand même ?",
-                f"Recommended action: run 'git checkout {locked_commit}' manually before continuing.\n\nContinue build anyway?"
+                f"Action manuelle recommandée :\n{cmd_hint}\nContinuer le build quand même ?",
+                f"Recommended manual action:\n{cmd_hint}\nContinue build anyway?"
             )
             ans = QMessageBox.warning(self, "Git Mismatch", msg, QMessageBox.Yes | QMessageBox.No)
             return ans == QMessageBox.Yes