Commit changes and add service modules

Author: raidos23

Core/Services/DependencyService.py

@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import ast
+import functools
+import importlib.util
+import json
+import os
+import re
+import sys
+import sysconfig
+from pathlib import Path
+from typing import Any, List, Set, Tuple
+
+import yaml
+from importlib.metadata import distribution, PackageNotFoundError
+
+class DependencyService:
+    """Business logic for dependency analysis."""
+
+    @staticmethod
+    def _default_excluded_stdlib() -> set[str]:
+        return {
+            "sys", "os", "re", "subprocess", "json", "math", "time", "pathlib", "typing",
+            "itertools", "functools", "collections", "asyncio", "importlib", "inspect",
+            "logging", "argparse", "dataclasses", "unittest", "threading", "multiprocessing",
+            "http", "urllib", "email", "socket", "ssl", "hashlib", "hmac", "gzip", "bz2",
+            "lzma", "base64", "shutil", "tempfile", "glob", "fnmatch", "statistics", "pprint",
+            "getpass", "uuid", "enum", "contextlib", "queue", "traceback", "warnings", "gc",
+            "platform", "sysconfig", "pkgutil", "site", "venv", "sqlite3", "tkinter",
+        }
+
+    @staticmethod
+    def _load_excluded_stdlib() -> set[str]:
+        default = DependencyService._default_excluded_stdlib()
+        # Mapping file still in the old location for now, but should ideally move to Core/Services/data
+        mapping_path = os.path.join(os.path.dirname(__file__), "..", "..", "Ui", "Gui", "DepsAnalyser", "stblib.yml")
+        if not os.path.isfile(mapping_path):
+             # Try absolute path from project root
+             mapping_path = os.path.join(os.getcwd(), "Ui", "Gui", "DepsAnalyser", "stblib.yml")
+        
+        if not os.path.isfile(mapping_path):
+            return default
+        try:
+            with open(mapping_path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            modules = None
+            if isinstance(data, dict):
+                modules = data.get("excluded_stdlib")
+                if modules is None:
+                    modules = data.get("modules")
+            elif isinstance(data, list):
+                modules = data
+            if not isinstance(modules, list):
+                return default
+            cleaned = [m.strip() for m in modules if isinstance(m, str) and m.strip()]
+            return set(cleaned) or default
+        except Exception:
+            return default
+
+    EXCLUDED_STDLIB = _load_excluded_stdlib()
+
+    @staticmethod
+    @functools.lru_cache(maxsize=256)
+    def is_stdlib_module(module_name: str) -> bool:
+        try:
+            if module_name in DependencyService.EXCLUDED_STDLIB:
+                return True
+            if module_name in sys.builtin_module_names:
+                return True
+            spec = importlib.util.find_spec(module_name)
+            if spec is None:
+                return False
+            if getattr(spec, "origin", None) in ("built-in", "frozen"):
+                return True
+            stdlib_path = sysconfig.get_path("stdlib") or ""
+            stdlib_path = os.path.realpath(stdlib_path)
+            candidates = []
+            if getattr(spec, "origin", None):
+                candidates.append(os.path.realpath(spec.origin))
+            for loc in spec.submodule_search_locations or []:
+                candidates.append(os.path.realpath(loc))
+            for c in candidates:
+                try:
+                    if os.path.commonpath([c, stdlib_path]) == stdlib_path:
+                        return True
+                except Exception:
+                    pass
+            return False
+        except Exception:
+            return False
+
+    @staticmethod
+    def normalize_realpath(path: str | None) -> str:
+        if not path:
+            return ""
+        try:
+            return os.path.normcase(os.path.realpath(path))
+        except Exception:
+            return path
+
+    @staticmethod
+    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
+        except Exception:
+            return False
+
+    @staticmethod
+    def normalize_module_name(name: str | None) -> str:
+        if not name:
+            return ""
+        try:
+            cleaned = re.sub(r"[^A-Za-z0-9_\.]+", "_", str(name).strip())
+            return cleaned.replace("-", "_").strip("._")
+        except Exception:
+            return ""
+
+    @staticmethod
+    def top_level_module_name(name: str | None) -> str:
+        normalized = DependencyService.normalize_module_name(name)
+        if not normalized:
+            return ""
+        return normalized.split(".")[0]
+
+    @staticmethod
+    def extract_imported_modules_from_source(
+        source: str, file_path: str = "", workspace_dir: str | None = None
+    ) -> set[str]:
+        modules: set[str] = set()
+        try:
+            tree = ast.parse(source, filename=file_path or "<memory>")
+        except Exception:
+            return modules
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    top = DependencyService.top_level_module_name(alias.name)
+                    if top:
+                        modules.add(top)
+            elif isinstance(node, ast.ImportFrom):
+                if node.level and node.level > 0:
+                    # Circular dependency if we import from WorkspaceService here
+                    # For now, we'll implement a minimal version of relative parts
+                    pass
+                elif node.module:
+                    top = DependencyService.top_level_module_name(node.module)
+                    if top:
+                        modules.add(top)
+
+        dynamic_imports = re.findall(r"__import__\(['\"]([\w\.]+)['\"]\)", source)
+        modules.update(
+            [top for top in (DependencyService.top_level_module_name(mod) for mod in dynamic_imports) if top]
+        )
+
+        importlib_imports = re.findall(
+            r"importlib\.import_module\(['\"]([\w\.]+)['\"]\)", source
+        )
+        modules.update(
+            [
+                top
+                for top in (DependencyService.top_level_module_name(mod) for mod in importlib_imports)
+                if top
+            ]
+        )
+        return modules
+
+    @staticmethod
+    def extract_imported_modules_from_file(
+        file_path: str, workspace_dir: str | None = None
+    ) -> set[str]:
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                source = f.read()
+        except Exception:
+            return set()
+        return DependencyService.extract_imported_modules_from_source(
+            source,
+            file_path=file_path,
+            workspace_dir=workspace_dir,
+        )
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1024)
+    def classify_module_origin(module_name: str, workspace_dir: str) -> str:
+        if not module_name:
+            return "unknown"
+        if DependencyService.is_stdlib_module(module_name):
+            return "stdlib"
+        try:
+            ws = DependencyService.normalize_realpath(workspace_dir)
+            # Minimal internal detection
+            normalized_module = DependencyService.top_level_module_name(module_name)
+            if normalized_module:
+                 # Check common source roots
+                 for root in (ws, os.path.join(ws, "src"), os.path.join(ws, "lib")):
+                    try:
+                        pkg_init = os.path.join(root, normalized_module, "__init__.py")
+                        mod_file = os.path.join(root, f"{normalized_module}.py")
+                        if os.path.isfile(pkg_init) or os.path.isfile(mod_file):
+                            return "internal"
+                    except Exception:
+                        continue
+
+            spec = importlib.util.find_spec(module_name)
+            if spec is None:
+                return "unknown"
+            origin = getattr(spec, "origin", None)
+            if origin in ("built-in", "frozen"):
+                return "stdlib"
+
+            candidates: list[str] = []
+            if origin:
+                candidates.append(DependencyService.normalize_realpath(origin))
+            for loc in spec.submodule_search_locations or []:
+                candidates.append(DependencyService.normalize_realpath(loc))
+
+            stdlib_path = DependencyService.normalize_realpath(sysconfig.get_path("stdlib") or "")
+            purelib_path = DependencyService.normalize_realpath(sysconfig.get_path("purelib") or "")
+            platlib_path = DependencyService.normalize_realpath(sysconfig.get_path("platlib") or "")
+            for c in candidates:
+                if ws and DependencyService.is_path_under(c, ws):
+                    return "internal"
+                if stdlib_path and DependencyService.is_path_under(c, stdlib_path):
+                    return "stdlib"
+                if purelib_path and DependencyService.is_path_under(c, purelib_path):
+                    return "third_party"
+                if platlib_path and DependencyService.is_path_under(c, platlib_path):
+                    return "third_party"
+                if "site-packages" in c or "dist-packages" in c:
+                    return "third_party"
+
+            return "unknown"
+        except Exception:
+            return "unknown"
+
+    @staticmethod
+    def check_module_installed(module: str) -> bool:
+        try:
+            distribution(module)
+            return True
+        except PackageNotFoundError:
+            return False
+        except Exception:
+            return False