deps-analyser: renforcer la détection interne/externe des imports

- Améliore la normalisation de chemins et la classification stdlib/internal/third_party/unknown.

- Ajoute des heuristiques robustes: chaînes __init__.py, layouts src/lib/python, pyproject.toml et setup.cfg.

- Corrige le filtrage des fichiers analysés (venv, caches, artefacts) et prend mieux en charge certains imports relatifs.

Author: raidos23

Core/deps_analyser/analyser.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 import functools
+import configparser
 import json
 import os
 import platform
@@ -185,7 +186,7 @@ def _normalize_realpath(path: str | None) -> str:
     if not path:
         return ""
     try:
-        return os.path.realpath(path)
+        return os.path.realpath(os.path.abspath(path))
     except Exception:
         return path
 
@@ -194,7 +195,9 @@ def _is_path_under(path: str, root: str) -> bool:
     if not path or not root:
         return False
     try:
-        return os.path.commonpath([path, root]) == root
+        p = _normalize_realpath(path)
+        r = _normalize_realpath(root)
+        return os.path.commonpath([p, r]) == r
     except Exception:
         return False
 
@@ -203,33 +206,116 @@ def _collect_workspace_module_roots(
     filtered_files: list[str], workspace_dir: str | None
 ) -> set[str]:
     """
-    Build a conservative set of internal module roots from workspace files.
-    Handles common src-layout aliases (src/, lib/, python/).
+    Build internal module roots from workspace files.
+    Uses __init__.py package chains, src-layout aliases and project metadata.
     """
     roots: set[str] = set()
     ws = _normalize_realpath(workspace_dir)
-    src_aliases = {"src", "lib", "python"}
+    if not ws:
+        return roots
+
+    def _sanitize_module_name(name: str) -> str:
+        if not name:
+            return ""
+        token = str(name).strip().replace("-", "_").split(".")[0]
+        return token if token.isidentifier() else ""
+
+    def _add_declared_project_names() -> None:
+        pyproject_path = os.path.join(ws, "pyproject.toml")
+        if os.path.isfile(pyproject_path):
+            try:
+                import tomllib
+
+                with open(pyproject_path, "rb") as f:
+                    data = tomllib.load(f)
+                candidates = []
+                project = data.get("project", {})
+                if isinstance(project, dict):
+                    candidates.append(project.get("name", ""))
+                tool = data.get("tool", {})
+                if isinstance(tool, dict):
+                    poetry = tool.get("poetry", {})
+                    if isinstance(poetry, dict):
+                        candidates.append(poetry.get("name", ""))
+                for candidate in candidates:
+                    module_name = _sanitize_module_name(candidate)
+                    if module_name:
+                        roots.add(module_name)
+            except Exception:
+                pass
+
+        setup_cfg_path = os.path.join(ws, "setup.cfg")
+        if os.path.isfile(setup_cfg_path):
+            try:
+                parser = configparser.ConfigParser()
+                parser.read(setup_cfg_path, encoding="utf-8")
+                if parser.has_section("metadata"):
+                    module_name = _sanitize_module_name(
+                        parser.get("metadata", "name", fallback="")
+                    )
+                    if module_name:
+                        roots.add(module_name)
+            except Exception:
+                pass
+
+    def _add_chain_from_init(module_dir: str) -> None:
+        current_dir = module_dir
+        top_package_name = ""
+        while _is_path_under(current_dir, ws):
+            init_py = os.path.join(current_dir, "__init__.py")
+            if not os.path.isfile(init_py):
+                break
+            rel_dir = os.path.relpath(current_dir, ws)
+            parts = [p for p in rel_dir.split(os.sep) if p]
+            if parts:
+                if parts[0] in {"src", "lib", "python"} and len(parts) > 1:
+                    top_package_name = parts[1]
+                else:
+                    top_package_name = parts[0]
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:
+                break
+            current_dir = parent
+        if top_package_name:
+            roots.add(top_package_name)
+
     for f in filtered_files:
         try:
             abs_f = _normalize_realpath(f)
-            base = os.path.splitext(os.path.basename(abs_f))[0]
-            if base and base != "__init__":
-                roots.add(base)
-            if not ws or not _is_path_under(abs_f, ws):
+            if not _is_path_under(abs_f, ws):
                 continue
             rel = os.path.relpath(abs_f, ws)
-            parts = rel.split(os.sep)
+            rel_no_ext = os.path.splitext(rel)[0]
+            parts = [p for p in rel_no_ext.split(os.sep) if p]
             if not parts:
                 continue
-            first = parts[0]
-            if first and first not in {"", ".", "__pycache__"}:
-                roots.add(first)
-            if first in src_aliases and len(parts) > 1:
-                second = parts[1]
-                if second and second not in {"", ".", "__pycache__"}:
-                    roots.add(second)
+            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])
+                _add_chain_from_init(os.path.dirname(abs_f))
         except Exception:
             pass
+
+    # Extra scan for top-level packages that may not be in the selected file list.
+    for layout in ("", "src", "lib", "python"):
+        base_dir = ws if not layout else os.path.join(ws, layout)
+        if not os.path.isdir(base_dir):
+            continue
+        try:
+            for entry in os.listdir(base_dir):
+                if entry.startswith("."):
+                    continue
+                entry_path = os.path.join(base_dir, entry)
+                if not os.path.isdir(entry_path):
+                    continue
+                if os.path.isfile(os.path.join(entry_path, "__init__.py")) and entry.isidentifier():
+                    roots.add(entry)
+        except Exception:
+            pass
+
+    _add_declared_project_names()
     return roots
 
 
@@ -447,37 +533,38 @@ def _t(_key: str, fr: str, en: str) -> str:
         venv_dir = os.path.abspath(self.venv_path_manuel)
     else:
         venv_dir = os.path.abspath(os.path.join(self.workspace_dir, "venv"))
-    filtered_files = [
-        f
-        for f in files
-        if not os.path.commonpath([os.path.abspath(f), venv_dir]) == venv_dir
-        and not any(
-            part.startswith(".")
-            or part
-            == (
-                "**/__pycache__/**",
-                "**/*.pyc",
-                "**/*.pyo",
-                "**/*.pyd",
-                ".git/**",
-                ".svn/**",
-                ".hg/**",
-                "venv/**",
-                ".venv/**",
-                "env/**",
-                ".env/**",
-                "node_modules/**",
-                "build/**",
-                "dist/**",
-                "*.egg-info/**",
-                ".pytest_cache/**",
-                ".mypy_cache/**",
-                ".tox/**",
-                "site-packages/**",
-            )
-            for part in f.split(os.sep)
-        )
-    ]
+    excluded_dir_names = {
+        "__pycache__",
+        ".git",
+        ".svn",
+        ".hg",
+        "venv",
+        ".venv",
+        "env",
+        ".env",
+        "node_modules",
+        "build",
+        "dist",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".tox",
+        "site-packages",
+    }
+    filtered_files = []
+    for file_path in files:
+        abs_file = os.path.abspath(file_path)
+        if _is_path_under(abs_file, venv_dir):
+            continue
+        rel_parts = [p for p in abs_file.split(os.sep) if p]
+        if any(p.startswith(".") and p not in {".", ".."} for p in rel_parts):
+            continue
+        if any(p in excluded_dir_names for p in rel_parts):
+            continue
+        if abs_file.endswith((".pyc", ".pyo", ".pyd")):
+            continue
+        if ".egg-info" in abs_file:
+            continue
+        filtered_files.append(file_path)
 
     # Créer une barre de progression pour l'analyse
     analysis_progress = None
@@ -521,6 +608,11 @@ def _t(_key: str, fr: str, en: str) -> str:
                 elif isinstance(node, ast.ImportFrom):
                     if node.module:
                         modules.add(node.module.split(".")[0])
+                    elif getattr(node, "level", 0) > 0:
+                        for alias in getattr(node, "names", []) or []:
+                            name = getattr(alias, "name", "")
+                            if name:
+                                modules.add(name.split(".")[0])
             # Imports dynamiques via __import__ ou importlib.import_module
             dynamic_imports = re.findall(r"__import__\(['\"]([\w\.]+)['\"]\)", source)
             modules.update([mod.split(".")[0] for mod in dynamic_imports])