metripy 0.2.7__py3-none-any.whl

metripy/Dependency/Npm/NpmOrg.py

@@ -0,0 +1,47 @@
+import requests
+
+from metripy.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

metripy/Dependency/Pip/Pip.py

@@ -0,0 +1,69 @@
+import os
+import re
+
+import toml
+
+from metripy.Dependency.Dependency import Dependency
+from metripy.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("./")

metripy/Dependency/Pip/PyPi.py

@@ -0,0 +1,49 @@
+import requests
+
+from metripy.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

metripy/Git/GitAnalyzer.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+from datetime import datetime
+
+from git import Repo
+
+from metripy.Application.Config.GitConfig import GitConfig
+from metripy.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,
+        )

metripy/LangAnalyzer/AbstractLangAnalyzer.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.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

metripy/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,
+        }

metripy/LangAnalyzer/Php/PhpAnalyzer.py

@@ -0,0 +1,193 @@
+import math
+from pathlib import Path
+
+import lizard
+
+from metripy.Component.Output.ProgressBar import ProgressBar
+from metripy.LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from metripy.LangAnalyzer.Php.PhpBasicAstParser import PhpBasicAstParser
+from metripy.LangAnalyzer.Php.PhpBasicLocAnalyzer import PhpBasicLocAnalyzer
+from metripy.LangAnalyzer.Php.PhpHalSteadAnalyzer import PhpHalSteadAnalyzer
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Tree.ClassNode import ClassNode
+from metripy.Tree.FunctionNode import FunctionNode
+from metripy.Tree.ModuleNode import ModuleNode
+
+
+class PhpAnalyzer(AbstractLangAnalyzer):
+    def __init__(self):
+        super().__init__()
+        self.loc_analyzer = PhpBasicLocAnalyzer()
+        self.halstead_analyzer = PhpHalSteadAnalyzer()
+
+    def get_lang_name(self) -> str:
+        return "PHP"
+
+    def set_files(self, files: list[str]) -> None:
+        self.files = list(filter(lambda file: file.endswith(".php"), files))
+
+    def is_needed(self) -> bool:
+        return len(self.files) > 0
+
+    def run(self, progress_bar: ProgressBar) -> None:
+        for file in self.files:
+            with open(file, "r") as f:
+                code = f.read()
+                self.analyze(code, file)
+            progress_bar.advance()
+
+    @staticmethod
+    def full_name(
+        filename: str, item_name: str | None = None, class_name: str | None = None
+    ) -> str:
+        if class_name is None:
+            if item_name is None:
+                return filename
+            return f"{filename}:{item_name}"
+        return f"{filename}:{class_name}:{item_name}"
+
+    def analyze(self, code: str, filename: str) -> None:
+        file_stem = Path(filename).stem
+        structure = PhpBasicAstParser.parse_php_structure(code)
+
+        lizard_result = lizard.analyze_file(filename)
+        complexity_data = {
+            func.name: {
+                "complexity": func.cyclomatic_complexity,
+                "start_line": func.start_line,
+                "end_line": func.end_line,
+            }
+            for func in lizard_result.function_list
+        }
+
+        classes: dict[str, ClassNode] = {}
+        functions: dict[str, FunctionNode] = {}
+        for obj in structure:
+            if obj["type"] == "class":
+                full_name = self.full_name(filename, obj["name"])
+                classes[full_name] = ClassNode(
+                    full_name,
+                    obj["name"],
+                    obj["line"],
+                    0,
+                    0,  # gets filled in later, based on methods
+                )
+            elif obj["type"] == "method" or obj["type"] == "function":
+                full_name = self.full_name(filename, obj["name"])
+                try:
+                    function_node = FunctionNode(
+                        full_name,
+                        obj["name"],
+                        obj["line"],
+                        0,
+                        complexity_data[f"{file_stem}::{obj['name']}"]["complexity"],
+                    )
+                    function_node.line_end = complexity_data[
+                        f"{file_stem}::{obj['name']}"
+                    ]["end_line"]
+                except KeyError:
+                    # no complexity data, function must be empty
+                    function_node = FunctionNode(
+                        full_name,
+                        obj["name"],
+                        obj["line"],
+                        0,
+                        0,
+                    )
+
+                if obj["type"] == "method":
+                    class_name = obj["class"]
+                    full_class_name = self.full_name(filename, class_name)
+                    class_node = classes.get(full_class_name)
+                    if class_node is not None:
+                        class_node.functions.append(function_node)
+                    else:
+                        raise ValueError(
+                            f"Class node not found for function {full_class_name}"
+                        )
+                functions[full_name] = function_node
+
+        # complexity of classes
+        for class_node in classes.values():
+            class_node.real_complexity = sum(
+                [func.complexity for func in class_node.functions]
+            )
+
+        loc_data = self.loc_analyzer.get_loc_metrics(code, filename)
+
+        full_name = self.full_name(filename)
+        module_node = ModuleNode(
+            full_name,
+            loc_data.get("lines", 0),
+            loc_data.get("linesOfCode", 0),
+            loc_data.get("logicalLinesOfCode", 0),
+            loc_data.get("commentLines", 0),
+            0,  # multi-line comments - not directly available
+            loc_data.get("linesOfCode", 0) - loc_data.get("logicalLinesOfCode", 0),
+            loc_data.get("commentLines", 0),
+        )
+        module_node.classes.extend(classes.values())
+        module_node.functions.extend(functions.values())
+
+        code_lines = code.split("\n")
+        for func_name, function_node in functions.items():
+            lines = code_lines[function_node.lineno:function_node.line_end]
+            function_metrics = self.halstead_analyzer.calculate_halstead_metrics(
+                "\n".join(lines)
+            )
+            function_node.h1 = function_metrics["n1"]
+            function_node.h2 = function_metrics["n2"]
+            function_node.N1 = function_metrics["N1"]
+            function_node.N2 = function_metrics["N2"]
+            function_node.vocabulary = function_metrics["vocabulary"]
+            function_node.length = function_metrics["length"]
+            function_node.volume = function_metrics["volume"]
+            function_node.difficulty = function_metrics["difficulty"]
+            function_node.effort = function_metrics["effort"]
+            function_node.calculated_length = function_metrics["calculated_length"]
+            function_node.bugs = function_metrics["bugs"]
+            function_node.time = function_metrics["time"]
+
+        maintainability_index = self._calculate_maintainability_index(
+            functions.values(), module_node
+        )
+        module_node.maintainability_index = maintainability_index
+        self.modules[full_name] = module_node
+
+    def _calculate_maintainability_index(
+        self, functions: list[FunctionNode], module_node: ModuleNode
+    ) -> float:
+        """Calculate maintainability index for PHP"""
+        if not functions:
+            return 100.0
+
+        total_volume = sum(func.volume for func in functions)
+        total_complexity = sum(func.complexity for func in functions)
+        total_length = sum(func.length for func in functions)
+
+        if total_volume == 0 or total_length == 0:
+            return 100.0
+
+        # PHP maintainability index calculation
+        mi_base = max(
+            (
+                171
+                - 5.2 * math.log(total_volume)
+                - 0.23 * total_complexity
+                - 16.2 * math.log(total_length)
+            )
+            * 100
+            / 171,
+            0,
+        )
+
+        # Comment weight
+        comment_weight = 0
+        if module_node.loc > 0:
+            comment_ratio = module_node.single_comments / module_node.loc
+            comment_weight = 50 * math.sin(math.sqrt(2.4 * comment_ratio))
+
+        return mi_base + comment_weight
+
+    def get_metrics(self) -> list[FileMetrics]:
+        return super().get_metrics()

metripy/LangAnalyzer/Php/PhpBasicAstParser.py

@@ -0,0 +1,56 @@
+import re
+
+
+class PhpBasicAstParser:
+
+    @staticmethod
+    def parse_php_structure(code: str):
+
+        # Regex patterns
+        class_pattern = re.compile(r"class\s+(\w*)")
+        interface_pattern = re.compile(r"interface\s+(\w*)")
+        method_pattern = re.compile(r"function\s+(\w+)\s*\([^)]*\)?")
+        function_pattern = re.compile(r"function\s+(\w+)\s*\([^)]*\)?")
+
+        lines = code.split("\n")
+        structure = []
+        current_class = None
+
+        for i, line in enumerate(lines):
+            class_match = class_pattern.search(line)
+            if class_match:
+                current_class = class_match.group(1)
+                structure.append(
+                    {"type": "class", "name": current_class, "line": i + 1}
+                )
+
+            interface_match = interface_pattern.search(line)
+            if interface_match:
+                current_class = interface_match.group(1)
+                structure.append(
+                    {
+                        "type": "class",
+                        "type_type": "interface",
+                        "name": current_class,
+                        "line": i + 1,
+                    }
+                )
+
+            method_match = method_pattern.search(line)
+            if method_match and current_class:
+                structure.append(
+                    {
+                        "type": "method",
+                        "name": method_match.group(1),
+                        "class": current_class,
+                        "line": i + 1,
+                    }
+                )
+
+            elif function_pattern.search(line) and not current_class:
+                function_name = function_pattern.search(line).group(1)
+                structure.append(
+                    {"type": "function", "name": function_name, "line": i + 1}
+                )
+
+        return structure