metripy 0.2.5__py3-none-any.whl

src/Component/Output/CliOutput.py

@@ -0,0 +1,49 @@
+import re
+import sys
+from typing import Self
+
+
+class CliOutput:
+    def __init__(self):
+        self.quiet_mode = False
+
+    def set_quiet_mode(self, quiet_mode: bool):
+        self.quiet_mode = quiet_mode
+
+    def writeln(self, message: str) -> Self:
+        self.write(str(message), end="\n")
+
+        return self
+
+    def write(self, message: str, end="") -> Self:
+        if matches := re.search(r"<([a-z]+)>(.*?)</([a-z]+)>", message):
+            type = matches.group(1)
+            message = matches.group(2)
+            color = {
+                "error": "\033[31m",
+                "warning": "\033[33m",
+                "success": "\033[32m",
+                "info": "\033[34m",
+                "debug": "\033[95m",
+            }
+            message = color[type] + message + "\033[0m"
+
+        if not self.quiet_mode:
+            print(message, end=end)
+
+        return self
+
+    def err(self, message: str) -> Self:
+        sys.stderr.write(message)
+
+        return self
+
+    def clearln(self) -> Self:
+        if self.has_ansi():
+            self.write("\x0d")
+            self.write("\x1b[2K")
+
+        return self
+
+    def has_ansi(self) -> bool:
+        return sys.stdout.isatty()

src/Component/Output/ProgressBar.py

@@ -0,0 +1,27 @@
+from Component.Output.CliOutput import CliOutput
+
+
+class ProgressBar:
+    def __init__(self, output: CliOutput, total: int):
+        self.output = output
+        self.total = total
+        self.current = 0
+
+    def start(self):
+        self.current = 0
+
+    def advance(self):
+        self.current += 1
+
+        if self.output.has_ansi():
+            percent = round(self.current / self.total * 100)
+            self.output.write("\x0d")
+            self.output.write("\x1b[2K")
+            self.output.write(f"... {percent}% ...")
+        else:
+            self.output.write(".")
+
+    def clear(self):
+        if self.output.has_ansi():
+            self.output.write("\x0d")
+            self.output.write("\x1b[2K")

src/Dependency/Composer/Composer.py

@@ -0,0 +1,30 @@
+import json
+import os
+
+from Dependency.Composer.Packegist import Packegist
+from Dependency.Dependency import Dependency
+
+
+class Composer:
+    def get_composer_dependencies(self, composer_json_path: str):
+        requirements = self.get_composer_json_requirements(composer_json_path)
+
+        packegist = Packegist()
+        packages = []
+        for dependency in requirements:
+            package = packegist.get_info(dependency)
+            packages.append(package)
+
+        return [item for item in packages if item is not None]
+
+    def get_composer_json_requirements(self, composer_json_path) -> list:
+        requirements = []
+        with open(os.path.join(composer_json_path, "composer.json"), "r") as file:
+            composer_json = json.load(file)
+            require = composer_json.get("require", None)
+            if require is None:
+                return []
+            for name, version in require.items():
+                requirements.append(Dependency(name, version))
+
+        return requirements

src/Dependency/Composer/Packegist.py

@@ -0,0 +1,55 @@
+import re
+
+import requests
+from packaging import version
+
+from Dependency.Dependency import Dependency
+
+
+class Packegist:
+    def get_info(self, dependency: Dependency) -> Dependency | None:
+        if "/" not in dependency.name:
+            return None
+        [user, name] = dependency.name.split("/", 2)
+        uri = f"https://packagist.org/packages/{user}/{name}.json"
+
+        x = requests.get(uri)
+        d = x.json()
+
+        package_info = d.get("package", None)
+        if package_info is None:
+            print(f"package of {dependency.name} has no package info")
+            return dependency
+
+        dependency.type = package_info["type"]
+        dependency.description = package_info["description"]
+        dependency.repository = package_info["repository"]
+        dependency.github_stars = package_info["github_stars"]
+        dependency.downloads_total = package_info["downloads"]["total"]
+        dependency.downloads_monthly = package_info["downloads"]["monthly"]
+        dependency.downloads_daily = package_info["downloads"]["daily"]
+
+        latest = version.parse("0.0.0")
+        versions = package_info["versions"]
+        for ver_str, datas in versions.items():
+            # Strip leading 'v' if present
+            if ver_str.startswith("v"):
+                ver_str = ver_str[1:]
+
+            # Skip non-semver strings
+            if not re.match(r"^[\d.]+$", ver_str):
+                continue
+
+            current_version = version.parse(ver_str)
+            if current_version > latest:
+                latest = current_version
+                dependency.latest = ver_str
+                dependency.license = datas.get("license", [])
+                dependency.homepage = datas.get("homepage")
+                dependency.zip = datas.get("dist", {}).get("url")
+
+        if dependency.version == dependency.latest:
+            dependency.status = "latest"
+        else:
+            dependency.status = "outdated"
+        return dependency

src/Dependency/Dependency.py

@@ -0,0 +1,30 @@
+class Dependency:
+    def __init__(self, name: str, version: str):
+        self.name = name
+        self.version = version
+        self.latest: str = ""
+        self.status: str = "unknown"
+        self.type: str = ""
+        self.description: str = ""
+        self.repository: str = ""
+        self.github_stars: int = 0
+        self.downloads_total: int = 0
+        self.downloads_monthly: int = 0
+        self.downloads_daily: int = 0
+        self.license: list[str] = []
+        self.homepage: str = ""
+        self.zip: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "latest": self.latest,
+            "status": self.status,
+            "type": self.type,
+            "description": self.description,
+            "repository": self.repository,
+            "github_stars": self.github_stars,
+            "downloads_monthly": self.downloads_monthly,
+            "licenses": ",".join(self.license),
+        }

src/Dependency/Npm/Npm.py

@@ -0,0 +1,30 @@
+import json
+import os
+
+from Dependency.Dependency import Dependency
+from Dependency.Npm.NpmOrg import NpmOrg
+
+
+class Npm:
+    def get_dependencies(self, path: str) -> list[Dependency]:
+        requirements = self._get_requirements(path)
+
+        npm_org = NpmOrg()
+        packages = []
+        for dependency in requirements:
+            package = npm_org.get_info(dependency)
+            packages.append(package)
+
+        return [item for item in packages if item is not None]
+
+    def _get_requirements(self, path: str) -> list[Dependency]:
+        requirements = []
+        with open(os.path.join(path, "package.json"), "r") as file:
+            package_json = json.load(file)
+            dependencies = package_json.get("dependencies", None)
+            if dependencies is None:
+                return None
+            for name, version in dependencies.items():
+                requirements.append(Dependency(name, version))
+
+        return requirements

src/Dependency/Npm/NpmOrg.py

@@ -0,0 +1,47 @@
+import requests
+
+from Dependency.Dependency import Dependency
+
+
+class NpmOrg:
+    def get_info(self, dependency: Dependency) -> Dependency | None:
+        if not dependency.name:
+            return None
+
+        uri = f"https://registry.npmjs.org/{dependency.name}"
+        response = requests.get(uri)
+
+        if response.status_code != 200:
+            print(f"Package {dependency.name} not found on npm.org")
+            return None
+
+        data = response.json()
+
+        # Basic metadata
+        dependency.type = "npm"
+        dependency.description = data.get("description", "")
+        dependency.repository = data.get("repository", {}).get("url", "")
+        dependency.homepage = data.get("homepage", "")
+        dependency.license = [data.get("license")] if data.get("license") else []
+
+        # Version info
+        latest_version = data.get("dist-tags", {}).get("latest", "")
+        dependency.latest = latest_version
+
+        # npm doesn't provide download stats in the registry API
+        dependency.github_stars = "??"
+        dependency.downloads_total = "??"
+        dependency.downloads_monthly = "??"
+        dependency.downloads_daily = "??"
+
+        # Determine status
+        if dependency.version == dependency.latest:
+            dependency.status = "latest"
+        else:
+            dependency.status = "outdated"
+
+        # build zip url
+        if latest_version:
+            dependency.zip = f"https://registry.npmjs.org/{dependency.name}/-/{dependency.name}-{latest_version}.tgz"
+
+        return dependency

src/Dependency/Pip/Pip.py

@@ -0,0 +1,69 @@
+import os
+import re
+
+import toml
+
+from Dependency.Dependency import Dependency
+from Dependency.Pip.PyPi import PyPi
+
+
+class Pip:
+    def get_dependencies(self, path: str) -> list[Dependency]:
+        try:
+            requirements = self.get_from_requirements_txt(path)
+        except FileNotFoundError:
+            requirements = self.get_from_pyproject_toml(path)
+
+        pypi = PyPi()
+        packages = []
+        for dependency in requirements:
+            package = pypi.get_info(dependency)
+            packages.append(package)
+
+        return [item for item in packages if item is not None]
+
+    def get_from_requirements_txt(self, path: str) -> list[Dependency]:
+        requirements = []
+
+        pattern = re.compile(r"([a-zA-Z0-9_\-]+)([<>=!~]+[^\s]+)?")
+        with open(os.path.join(path, "requirements.txt"), "r") as file:
+            lines = file.readlines()
+            for line in lines:
+
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    match = pattern.match(line)
+                    if match:
+                        name = match.group(1)
+                        version = match.group(2) if match.group(2) else None
+                        requirements.append(Dependency(name, version))
+        return requirements
+
+    def get_from_pyproject_toml(self, path: str) -> list[Dependency]:
+        dependencies = []
+
+        with open(os.path.join(path, "pyproject.toml"), "r") as f:
+            data = toml.load(f)
+
+            # For PEP 621 / setuptools projects
+            if "project" in data:
+                deps = data["project"].get("dependencies", [])
+                for dep in deps:
+                    # dep is a string like "requests>=2.32.5"
+                    # You can split it if needed
+                    if "==" in dep:
+                        name, version = dep.split("==")
+                    elif ">=" in dep:
+                        name, version = dep.split(">=")
+                    else:
+                        name, version = dep, None
+                    dependencies.append(
+                        Dependency(name.strip(), version.strip() if version else None)
+                    )
+
+        return dependencies
+
+
+if __name__ == "__main__":
+    pip = Pip()
+    pip.get_dependencies("./")

src/Dependency/Pip/PyPi.py

@@ -0,0 +1,49 @@
+import requests
+
+from Dependency.Dependency import Dependency
+
+
+class PyPi:
+    def get_info(self, dependency: Dependency) -> Dependency | None:
+        uri = f"https://pypi.org/pypi/{dependency.name}/json"
+        x = requests.get(uri)
+        data = x.json()
+
+        info = data.get("info", {})
+        releases = data.get("releases", {})
+
+        if not info:
+            print(f"Package '{dependency.name}' has no info section")
+            return dependency
+
+        dependency.description = info.get("summary")
+        dependency.repository = info.get("project_url") or info.get("home_page")
+        if info.get("license"):
+            dependency.license = [info.get("license")]
+        else:
+            dependency.license = []
+        dependency.homepage = info.get("home_page")
+
+        # PyPI doesn't provide GitHub stars or download counts directly
+        dependency.github_stars = "??"
+        dependency.downloads_total = "??"
+        dependency.downloads_monthly = "??"
+        dependency.downloads_daily = "??"
+
+        # Determine latest version
+        latest_version = info.get("version")
+        dependency.latest = latest_version
+
+        # Compare with current version
+        if dependency.version == latest_version:
+            dependency.status = "latest"
+        else:
+            dependency.status = "outdated"
+
+        # Get distribution URL (e.g., wheel or sdist)
+        if latest_version in releases:
+            release_files = releases[latest_version]
+            if release_files:
+                dependency.zip = release_files[0].get("url")
+
+        return dependency

src/Git/GitAnalyzer.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+from datetime import datetime
+
+from git import Repo
+
+from Application.Config.GitConfig import GitConfig
+from Metric.Git.GitMetrics import GitMetrics
+
+
+class GitAnalyzer:
+    def __init__(self, git_config: GitConfig):
+        print(git_config.repo)
+        print(git_config.branch)
+        self.repo = Repo(git_config.repo)
+        self.branch_name = git_config.branch
+
+    def analyze(self) -> GitMetrics:
+        """Main analysis method with comprehensive output"""
+
+        # Calculate first day of this month last year
+        now = datetime.now()
+        first_of_month_last_year = datetime(now.year - 1, now.month, 1)
+        # first_of_month_last_year = datetime(now.year, now.month, 1)
+        after_date = first_of_month_last_year.strftime("%Y-%m-%d")
+        print(f"analyzing from {after_date}")
+
+        return self.get_metrics(after_date)
+
+    def _is_source_file(self, file_path: str) -> bool:
+        """Check if file is a source code file we want to analyze"""
+        source_extensions = {
+            ".py",
+            ".js",
+            ".ts",
+            ".tsx",
+            ".php",
+            ".java",
+            ".cpp",
+            ".c",
+            ".h",
+            ".rb",
+            ".go",
+            ".rs",
+        }
+        return any(file_path.endswith(ext) for ext in source_extensions)
+
+    def get_metrics(self, after: str) -> GitMetrics:
+        commits_per_month = {}
+        chrun_per_month = defaultdict(lambda: {"added": 0, "removed": 0})
+        file_contributors = defaultdict(lambda: {"contributors": set(), "commits": 0})
+        contributor_stats = defaultdict(
+            lambda: {"commits": 0, "lines_added": 0, "lines_removed": 0}
+        )
+
+        for commit in self.repo.iter_commits(
+            self.branch_name, no_merges=True, after=after
+        ):
+            month = commit.committed_datetime.strftime("%Y-%m")
+            author = commit.author.name
+
+            if month not in commits_per_month.keys():
+                commits_per_month[month] = 0
+            commits_per_month[month] += 1
+
+            stats = commit.stats.total
+            insertions = stats.get("insertions", 0)
+            deletions = stats.get("deletions", 0)
+            chrun_per_month[month]["added"] += insertions
+            chrun_per_month[month]["removed"] += deletions
+
+            contributor_stats[author]["commits"] += 1
+            contributor_stats[author]["lines_added"] += insertions
+            contributor_stats[author]["lines_removed"] += deletions
+
+            for file_path in commit.stats.files:
+                if self._is_source_file(file_path):
+                    file_contributors[file_path]["contributors"].add(author)
+                    file_contributors[file_path]["commits"] += 1
+
+        return GitMetrics(
+            analysis_start_date=after,
+            commit_stats_per_month=commits_per_month,
+            churn_per_month=chrun_per_month,
+            contributor_stats=contributor_stats,
+            file_contributors=file_contributors,
+        )

src/LangAnalyzer/AbstractLangAnalyzer.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+
+from Metric.Code.FileMetrics import FileMetrics
+from Tree.ModuleNode import ModuleNode
+
+
+class AbstractLangAnalyzer(ABC):
+    def __init__(self):
+        self.files: list[str] = []
+        self.modules: dict[str, ModuleNode] = {}
+
+    @abstractmethod
+    def set_files(self, files: list[str]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def is_needed(self) -> bool:
+        pass
+
+    def before_run(self) -> None:
+        # build cache
+        pass
+
+    def after_run(self) -> None:
+        # clear cache
+        pass
+
+    @abstractmethod
+    def get_lang_name(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def run(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_metrics(self) -> list[FileMetrics]:
+        metrics = []
+        for module in self.modules.values():
+            full_name = module.full_name
+
+            if len(module.functions) > 0:
+                avgCcPerFunction = sum(
+                    function.complexity for function in module.functions
+                ) / len(module.functions)
+                avgLocPerFunction = (
+                    module.lloc - module.comments - len(module.functions)
+                ) / len(module.functions)
+            else:
+                avgCcPerFunction = 0
+                avgLocPerFunction = 0
+            maintainabilityIndex = module.maintainability_index
+
+            file_metric = FileMetrics(
+                full_name=full_name,
+                loc=module.loc,
+                avgCcPerFunction=avgCcPerFunction,
+                maintainabilityIndex=maintainabilityIndex,
+                avgLocPerFunction=avgLocPerFunction,
+                class_nodes=module.classes,
+                function_nodes=module.functions,
+            )
+            metrics.append(file_metric)
+
+        return metrics

src/LangAnalyzer/Generic/HalSteadAnalyzer.py

@@ -0,0 +1,58 @@
+import math
+import re
+from collections import Counter
+
+
+class HalSteadAnalyzer:
+    def __init__(self, operators: set):
+        self.operators: set = operators
+
+    def calculate_halstead_metrics(self, code: str):
+        # Tokenize the code
+        tokens = re.findall(r"\b\w+\b|[^\s\w]", code)
+
+        # Count operators and operands
+        operator_counts = Counter()
+        operand_counts = Counter()
+
+        for token in tokens:
+            if token in self.operators:
+                operator_counts[token] += 1
+            elif re.match(r"\b\w+\b", token):
+                operand_counts[token] += 1
+
+        # Halstead metrics
+        n1 = len(operator_counts)  # distinct operators
+        n2 = len(operand_counts)  # distinct operands
+        N1 = sum(operator_counts.values())  # total operators
+        N2 = sum(operand_counts.values())  # total operands
+
+        vocabulary = n1 + n2
+        length = N1 + N2
+        volume = length * math.log2(vocabulary) if vocabulary > 0 else 0
+        difficulty = (n1 / 2) * (N2 / n2) if n2 > 0 else 0
+        effort = difficulty * volume
+
+        calculated_length = 0
+        if n1 > 0:
+            calculated_length += n1 * math.log2(n1)
+        if n2 > 0:
+            calculated_length += n2 * math.log2(n2)
+
+        bugs = (effort ** (2 / 3)) / 3000 if effort > 0 else 0
+        time = effort / 18 if effort > 0 else 0
+
+        return {
+            "n1": n1,  # distinct operators
+            "n2": n2,  # distinct operands
+            "N1": N1,  # total operators
+            "N2": N2,  # total operands
+            "vocabulary": vocabulary,
+            "length": length,
+            "volume": volume,
+            "difficulty": difficulty,
+            "effort": effort,
+            "calculated_length": calculated_length,
+            "bugs": bugs,
+            "time": time,
+        }