deps-analyser: classification robuste des imports internes/externes

- Ajoute une classification d'origine des modules (stdlib/internal/third_party/unknown) via importlib.find_spec et chemins réels.

- Distingue mieux les modules internes du workspace, y compris les layouts src/lib/python.

- Corrige le filtre des fichiers analysés (venv, caches, build, dist, egg-info, etc.) qui était partiellement défaillant.

- Ajoute un log de synthèse des classes d'imports pour faciliter le diagnostic.

Author: raidos23

Core/deps_analyser/analyser.py

@@ -15,11 +15,14 @@
 
 import functools
 import configparser
+import importlib.util
 import json
 import os
 import platform
 import re
 import subprocess
+import sys
+import sysconfig
 import yaml
 from importlib.metadata import distribution, PackageNotFoundError
 
@@ -142,6 +145,89 @@ def _load_excluded_stdlib() -> set[str]:
 EXCLUDED_STDLIB = _load_excluded_stdlib()
 
 
+def _normalize_realpath(path: str) -> str:
+    try:
+        return os.path.realpath(os.path.abspath(path))
+    except Exception:
+        return path
+
+
+def _is_path_under(path: str, root: str) -> bool:
+    if not path or not root:
+        return False
+    try:
+        return os.path.commonpath([_normalize_realpath(path), _normalize_realpath(root)]) == _normalize_realpath(root)
+    except Exception:
+        return False
+
+
+def _collect_workspace_module_roots(filtered_files: list[str], workspace_dir: str) -> set[str]:
+    roots: set[str] = set()
+    ws_root = _normalize_realpath(workspace_dir)
+    if not ws_root:
+        return roots
+    for file_path in filtered_files:
+        norm = _normalize_realpath(file_path)
+        if not _is_path_under(norm, ws_root):
+            continue
+        rel_path = os.path.relpath(norm, ws_root)
+        rel_no_ext = os.path.splitext(rel_path)[0]
+        parts = [p for p in rel_no_ext.split(os.sep) if p]
+        if not parts:
+            continue
+        # src/lib/python layouts: prefer first meaningful package component.
+        if parts[0] in {"src", "lib", "python"} and len(parts) > 1:
+            roots.add(parts[1])
+        roots.add(parts[0])
+        if len(parts) > 1 and parts[-1] == "__init__":
+            roots.add(parts[-2])
+    return roots
+
+
+@functools.lru_cache(maxsize=1024)
+def _classify_module_origin(module_name: str, workspace_dir: str) -> str:
+    if not module_name:
+        return "unknown"
+    if module_name in EXCLUDED_STDLIB:
+        return "stdlib"
+    if module_name in sys.builtin_module_names:
+        return "stdlib"
+    try:
+        spec = importlib.util.find_spec(module_name)
+    except Exception:
+        return "unknown"
+    if spec is None:
+        return "unknown"
+    if getattr(spec, "origin", None) in ("built-in", "frozen"):
+        return "stdlib"
+
+    candidates = []
+    if getattr(spec, "origin", None):
+        candidates.append(_normalize_realpath(spec.origin))
+    for loc in getattr(spec, "submodule_search_locations", []) or []:
+        candidates.append(_normalize_realpath(loc))
+
+    ws_root = _normalize_realpath(workspace_dir)
+    for c in candidates:
+        if _is_path_under(c, ws_root):
+            return "internal"
+
+    stdlib_path = _normalize_realpath(sysconfig.get_path("stdlib") or "")
+    for c in candidates:
+        if _is_path_under(c, stdlib_path):
+            return "stdlib"
+
+    purelib = _normalize_realpath(sysconfig.get_path("purelib") or "")
+    platlib = _normalize_realpath(sysconfig.get_path("platlib") or "")
+    for c in candidates:
+        if _is_path_under(c, purelib) or _is_path_under(c, platlib):
+            return "third_party"
+        if "site-packages" in c or "dist-packages" in c:
+            return "third_party"
+
+    return "unknown"
+
+
 @functools.lru_cache(maxsize=256)
 def _is_stdlib_module(module_name: str) -> bool:
     """
@@ -627,8 +713,7 @@ def _t(_key: str, fr: str, en: str) -> str:
     if analysis_progress:
         analysis_progress.set_message(self.tr("Analyse terminée", "Analysis completed"))
         analysis_progress.set_progress(len(filtered_files), len(filtered_files))
-    # Classify imports as stdlib/internal/third-party/unknown.
-    ws_root = _normalize_realpath(getattr(self, "workspace_dir", None) or "")
+    ws_root = _normalize_realpath(self.workspace_dir or "")
     internal_modules = _collect_workspace_module_roots(filtered_files, ws_root)
     # Mise à jour du message de progression
     if analysis_progress: