Implémentation de la comparaison des verrous par équivalence fonctionnelle

Author: raidos23

Core/Locking/__init__.py

@@ -254,13 +254,77 @@ def cache_rebuild_lock(workspace: Path, payload: dict[str, Any]) -> str:
     return str(target)
 
 
-def compare_lock_payloads(left: dict[str, Any], right: dict[str, Any]) -> bool:
-    def comparable(payload: dict[str, Any]) -> dict[str, Any]:
-        data = dict(payload)
-        data.pop("build_id", None)
-        return data
+def get_functional_snapshot(payload: dict[str, Any]) -> dict[str, Any]:
+    """
+    Extract critical metadata for functional equivalence check.
+    Ignores non-functional fields like build_id, git_branch, or resolved_command.
+    """
+    if not isinstance(payload, dict):
+        return {}
+
+    project = payload.get("project") or {}
+    build = payload.get("build") or {}
+    engine = payload.get("engine") or {}
+    platform_info = payload.get("platform") or {}
+    dependencies = payload.get("dependencies") or {}
+
+    return {
+        "project": {
+            "name": str(project.get("name") or ""),
+            "version": str(project.get("version") or ""),
+            "entry": str(project.get("entry") or ""),
+            "git_commit": project.get("git_commit"),
+        },
+        "build": {
+            "output": str(build.get("output") or ""),
+            "data": list(build.get("data") or []),
+            "exclude": list(build.get("exclude") or []),
+            "icon": build.get("icon"),
+        },
+        "engine": {
+            "name": str(engine.get("name") or ""),
+            "version": str(engine.get("version") or ""),
+            "config": engine.get("config") or {},
+        },
+        "platform": {
+            "os": platform_info.get("os"),
+            "arch": platform_info.get("arch"),
+            "python_version": platform_info.get("python_version"),
+        },
+        "dependencies": dependencies,
+    }
+
+
+def compare_lock_payloads(
+    left: dict[str, Any], right: dict[str, Any], return_diff: bool = False
+) -> bool | tuple[bool, list[str]]:
+    """
+    Compare two build lock payloads for functional equivalence.
+    If return_diff is True, returns (is_equal, diff_list).
+    """
+    snap_left = get_functional_snapshot(left)
+    snap_right = get_functional_snapshot(right)
+
+    if not return_diff:
+        return snap_left == snap_right
+
+    diffs = []
+
+    def _diff_dict(a: dict, b: dict, path: str):
+        keys = set(a.keys()) | set(b.keys())
+        for k in sorted(keys):
+            val_a = a.get(k)
+            val_b = b.get(k)
+            cur_path = f"{path}.{k}" if path else k
+
+            if val_a != val_b:
+                if isinstance(val_a, dict) and isinstance(val_b, dict):
+                    _diff_dict(val_a, val_b, cur_path)
+                else:
+                    diffs.append(f"{cur_path}: {val_a} -> {val_b}")
 
-    return comparable(left) == comparable(right)
+    _diff_dict(snap_left, snap_right, "")
+    return (len(diffs) == 0, diffs)
 
 
 def default_lock_path(workspace: Path) -> Path:

Ui/Cli/app.py

@@ -289,9 +289,18 @@ def tr(self, fr, en):
             python_version=python_version,
         )
         rebuild_cache = cache_rebuild_lock(workspace, regenerated)
-        comparison = compare_lock_payloads(lock_payload, regenerated)
-        if not comparison:
+        comparison_ok, diffs = compare_lock_payloads(lock_payload, regenerated, return_diff=True)
+        comparison = comparison_ok
+        if not comparison_ok:
             warnings.append("Lock mismatch")
+            if not as_json and verbose:
+                from .output import warn
+                warn("Functional mismatch detected:")
+                for d in diffs:
+                    info(f"  - {d}")
+        elif not as_json and verbose:
+            from .output import success
+            success("Lock integrity confirmed (Functional Equivalence).")
     except Exception as exc:
         warnings.append(f"Unable to regenerate comparison lock: {exc}")
 

Ui/Gui/Dialogs/CompilerDialog.py

@@ -1119,15 +1119,18 @@ def handle_finished(self, return_code: int, info: dict) -> None:
                 )
 
                 rebuild_cache = cache_rebuild_lock(ws, regenerated)
-                comparison_ok = compare_lock_payloads(self._rebuild_lock_payload, regenerated)
+                comparison_ok, diffs = compare_lock_payloads(self._rebuild_lock_payload, regenerated, return_diff=True)
 
                 if not comparison_ok:
                     log_i18n_level(
                         self,
                         "warning",
-                        "⚠️ Mismatch détecté : le verrou actuel diffère de celui utilisé pour le rebuild.",
-                        "⚠️ Lock mismatch detected: the current configuration differs from the one in the lock file.",
+                        "⚠️ Mismatch fonctionnel détecté : le verrou actuel diffère de celui utilisé pour le rebuild.",
+                        "⚠️ Functional mismatch detected: the current configuration differs from the one in the lock file.",
                     )
+                    for d in diffs:
+                        log_with_level(self, "info", f"  - {d}")
+
                     if rebuild_cache:
                         log_i18n_level(
                             self,
@@ -1139,8 +1142,8 @@ def handle_finished(self, return_code: int, info: dict) -> None:
                     log_i18n_level(
                         self,
                         "success",
-                        "✅ Intégrité du verrou confirmée (Strict Alignment).",
-                        "✅ Lock integrity confirmed (Strict Alignment).",
+                        "✅ Intégrité du verrou confirmée (Équivalence Fonctionnelle).",
+                        "✅ Lock integrity confirmed (Functional Equivalence).",
                     )
             except Exception as exc:
                 log_i18n_level(

tests/test_lock_comparison.py

@@ -0,0 +1,46 @@
+import pytest
+from Core.Locking import compare_lock_payloads
+
+def test_compare_lock_payloads_functional_equivalence():
+    """Test that comparison ignores build_id but detects critical changes."""
+    lock_a = {
+        "build_id": "ARK_2026_05_31_001",
+        "project": {"name": "App", "version": "1.0.0", "entry": "main.py"},
+        "build": {"output": "dist/", "exclude": [], "data": []},
+        "engine": {"name": "nuitka", "version": "2.0", "config": {"standalone": True}},
+        "platform": {"os": "linux", "python_version": "3.12"},
+        "dependencies": {"requests": "2.31.0"}
+    }
+    
+    # Same functional metadata, different build_id
+    lock_b = dict(lock_a)
+    lock_b["build_id"] = "ARK_2026_05_31_002"
+    
+    assert compare_lock_payloads(lock_a, lock_b) is True
+    
+    # Different dependency version
+    lock_c = dict(lock_a)
+    lock_c["dependencies"] = {"requests": "2.32.0"}
+    assert compare_lock_payloads(lock_a, lock_c) is False
+    
+    # Different engine config
+    lock_d = dict(lock_a)
+    lock_d["engine"] = dict(lock_a["engine"])
+    lock_d["engine"]["config"] = {"standalone": False}
+    assert compare_lock_payloads(lock_a, lock_d) is False
+
+def test_compare_lock_payloads_with_diff():
+    """Test that we can get a list of differences."""
+    lock_a = {
+        "project": {"name": "App", "version": "1.0.0", "entry": "main.py"},
+        "dependencies": {"numpy": "1.24.0"}
+    }
+    lock_b = {
+        "project": {"name": "App", "version": "1.1.0", "entry": "main.py"},
+        "dependencies": {"numpy": "1.25.0"}
+    }
+    
+    ok, diffs = compare_lock_payloads(lock_a, lock_b, return_diff=True)
+    assert ok is False
+    assert any("project.version: 1.0.0 -> 1.1.0" in d for d in diffs)
+    assert any("dependencies.numpy: 1.24.0 -> 1.25.0" in d for d in diffs)