metripy 0.2.7__py3-none-any.whl

metripy/Metric/Git/GitMetrics.py

@@ -0,0 +1,148 @@
+from metripy.Metric.Git.GitCodeHotspot import GitCodeHotspot
+from metripy.Metric.Git.GitContributor import GitContributor
+from metripy.Metric.Git.GitKnowledgeSilo import GitKnowledgeSilo
+
+
+class GitMetrics:
+    def __init__(
+        self,
+        analysis_start_date: str,
+        commit_stats_per_month: dict[str, int],
+        churn_per_month: dict[str, dict[str, int]],
+        contributor_stats: dict[str, dict[str, int]],
+        file_contributors: dict[str, dict[str, int]],
+    ):
+        self.analysis_start_date = analysis_start_date
+        self._commit_stats_per_month: dict[str, int] = commit_stats_per_month
+        self._churn_per_month: dict[str, dict[str, int]] = churn_per_month
+        self._contributor_stats = contributor_stats
+        self.total_commits = sum(data["commits"] for data in contributor_stats.values())
+        self.contributors: list[GitContributor] = self._calc_contributors(
+            contributor_stats
+        )
+        self.core_contributors, self.core_percentage = self._calc_core_contributors(
+            self.contributors
+        )
+        self.silos: list[GitKnowledgeSilo] = self._calc_silos(file_contributors)
+        self.hotspots: list[GitCodeHotspot] = self._calc_hotspots(file_contributors)
+
+    def get_analysis_start_date(self) -> str:
+        return self.analysis_start_date
+
+    def get_commit_stats_per_month(self) -> dict[str, int]:
+        return self._commit_stats_per_month
+
+    def get_churn_per_month(self) -> dict[str, dict[str, int]]:
+        return self._churn_per_month
+
+    def get_avg_commit_size(self) -> float:
+        return (
+            sum(
+                data["lines_added"] + data["lines_removed"]
+                for data in self._contributor_stats.values()
+            )
+            / self.total_commits
+        )
+
+    def get_contributors_dict(self) -> dict[str, dict[str, int]]:
+        return {
+            contributor.name: contributor.to_dict() for contributor in self.contributors
+        }
+
+    def get_contributors_list(self) -> list[dict[str, int]]:
+        return [contributor.to_dict() for contributor in self.contributors]
+
+    def get_hotspots_list(self) -> list[dict[str, int]]:
+        return [hotspot.to_dict() for hotspot in self.hotspots]
+
+    def get_silos_dict(self) -> dict[str, dict[str, int]]:
+        return {silo.file_path: silo.to_dict() for silo in self.silos}
+
+    def get_silos_list(self) -> list[dict[str, int]]:
+        return [silo.to_dict() for silo in self.silos]
+
+    def _calc_hotspots(
+        self, file_contributors: dict[str, dict[str, int]]
+    ) -> list[GitCodeHotspot]:
+        hotspots = []
+        for file_path, data in file_contributors.items():
+            changes_count = data["commits"]
+            if changes_count < 10:
+                continue
+            hotspots.append(
+                GitCodeHotspot(
+                    file_path=file_path,
+                    changes_count=changes_count,
+                    contributors_count=len(data["contributors"]),
+                )
+            )
+        return sorted(hotspots, key=lambda x: x.changes_count, reverse=True)
+
+    def _calc_contributors(
+        self, contributor_stats: dict[str, dict[str, int]]
+    ) -> list[GitContributor]:
+        # determine top contributors
+        total_commits = self.total_commits
+        contributors = []
+
+        for name, data in contributor_stats.items():
+            percentage = (
+                (data["commits"] / total_commits * 100) if total_commits > 0 else 0
+            )
+            contributors.append(
+                GitContributor(
+                    name=name,
+                    commits_count=data["commits"],
+                    lines_added=data["lines_added"],
+                    lines_removed=data["lines_removed"],
+                    contribution_percentage=int(percentage),
+                )
+            )
+
+        return sorted(contributors, key=lambda x: x.commits_count, reverse=True)
+
+    def _calc_core_contributors(
+        self, contributors: list[GitContributor]
+    ) -> tuple[int, int]:
+        # Calculate core contributors (top contributors making up 67% of commits)
+        core_contributors = 0
+        core_percentage = 0
+        for contributor in contributors:
+            core_percentage += contributor.contribution_percentage
+            core_contributors += 1
+            if core_percentage >= 67:
+                break
+        core_percentage = min(67, core_percentage)
+
+        return core_contributors, core_percentage
+
+    def _calc_silos(
+        self, file_contributors: dict[str, dict[str, int]]
+    ) -> list[GitKnowledgeSilo]:
+        silos = []
+        for file_path, data in file_contributors.items():
+            if len(data["contributors"]) > 1 or data["commits"] < 3:
+                continue
+            owner = list(data["contributors"])[0]
+            silos.append(
+                GitKnowledgeSilo(
+                    file_path=file_path,
+                    owner=owner,
+                    commits_count=data["commits"],
+                )
+            )
+        return sorted(silos, key=lambda x: x.commits_count, reverse=True)
+
+    def to_dict(self) -> dict[str, any]:
+        return {
+            "analysis_start_date": self.analysis_start_date,
+            "avg_commit_size": f"{self.get_avg_commit_size():.2f}",
+            "commit_stats_per_month": self.get_commit_stats_per_month(),
+            "churn_per_month": self.get_churn_per_month(),
+            "total_commits": self.total_commits,
+            "active_contributors": len(self.contributors),
+            "contributors": self.get_contributors_dict(),
+            "core_contributors": self.core_contributors,
+            "core_percentage": self.core_percentage,
+            "silos": self.get_silos_list(),
+        }

metripy/Metric/ProjectMetrics.py

@@ -0,0 +1,55 @@
+from metripy.Dependency.Dependency import Dependency
+from metripy.Metric.Code.AggregatedMetrics import AggregatedMetrics
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+from metripy.Metric.Git.GitMetrics import GitMetrics
+
+
+class ProjectMetrics:
+    def __init__(
+        self,
+        file_metrics: list[FileMetrics],
+        git_metrics: GitMetrics | None,
+        dependencies: list[Dependency] | None,
+    ):
+        self.file_metrics = file_metrics
+        self.git_metrics = git_metrics
+        self.dependencies = dependencies
+        self.total_code_metrics = self._compile_total_metrics(self.file_metrics)
+
+    def _compile_total_metrics(
+        self, file_metrics: list[FileMetrics]
+    ) -> AggregatedMetrics:
+        files = 0
+        locs = []
+        avgCcPerFunctions = []
+        maintainabilityIndices = []
+        avgLocPerFunctions = []
+        for file_metric in file_metrics:
+            files += 1
+            locs.append(file_metric.loc)
+            avgCcPerFunctions.append(file_metric.avgCcPerFunction)
+            maintainabilityIndices.append(file_metric.maintainabilityIndex)
+            avgLocPerFunctions.append(file_metric.avgLocPerFunction)
+
+        if files == 0:
+            return AggregatedMetrics()
+
+        return AggregatedMetrics(
+            loc=sum(locs),
+            avgCcPerFunction=self._avg(avgCcPerFunctions),
+            maintainabilityIndex=self._avg(maintainabilityIndices),
+            avgLocPerFunction=self._avg(avgLocPerFunctions),
+            num_files=files,
+            segmented_loc=SegmentedMetrics().set_loc(locs),
+            segmented_complexity=SegmentedMetrics().set_complexity(avgCcPerFunctions),
+            segmented_maintainability=SegmentedMetrics().set_maintainability(
+                maintainabilityIndices
+            ),
+            segmented_method_size=SegmentedMetrics().set_method_size(
+                avgLocPerFunctions
+            ),
+        )
+
+    def _avg(self, items: list[float | int]) -> float:
+        return sum(items) / len(items)

metripy/Report/Csv/Reporter.py

@@ -0,0 +1,12 @@
+from metripy.Application.Config.Config import Config
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class Reporter:
+    def __init__(self, config: Config, output: CliOutput):
+        self.config = config
+        self.output = output
+
+    def generate(self, metrics: ProjectMetrics):
+        raise NotImplementedError("CSV metrics report is not yet implemented")

metripy/Report/Html/Reporter.py

@@ -0,0 +1,210 @@
+import json
+import os
+import shutil
+from datetime import datetime
+
+from py_template_engine import TemplateEngine
+
+from metripy.Application.Config.ReportConfig import ReportConfig
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.ReporterInterface import ReporterInterface
+
+
+class Reporter(ReporterInterface):
+    def __init__(
+        self, config: ReportConfig, output: CliOutput, project_name: str = "foobar"
+    ):
+        self.config: ReportConfig = config
+        self.output = output
+        self.template_dir = os.path.join(os.getcwd(), "templates/html_report")
+
+        self.global_template_args = {
+            "project_name": project_name,
+            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+
+    def generate(self, metrics: ProjectMetrics):
+
+        self.output.writeln("<info>Generating HTML report...</info>")
+
+        # copy sources
+        if not os.path.exists(os.path.join(self.config.path, "js")):
+            os.makedirs(os.path.join(self.config.path, "js"))
+        if not os.path.exists(os.path.join(self.config.path, "css")):
+            os.makedirs(os.path.join(self.config.path, "css"))
+        if not os.path.exists(os.path.join(self.config.path, "images")):
+            os.makedirs(os.path.join(self.config.path, "images"))
+        if not os.path.exists(os.path.join(self.config.path, "fonts")):
+            os.makedirs(os.path.join(self.config.path, "fonts"))
+        if not os.path.exists(os.path.join(self.config.path, "data")):
+            os.makedirs(os.path.join(self.config.path, "data"))
+
+        # shutil.copy(os.path.join(self.template_dir, "favicon.ico"), os.path.join(self.config.path, "favicon.ico"))
+
+        shutil.copytree(
+            os.path.join(self.template_dir, "js"),
+            os.path.join(self.config.path, "js"),
+            dirs_exist_ok=True,
+        )
+        shutil.copytree(
+            os.path.join(self.template_dir, "css"),
+            os.path.join(self.config.path, "css"),
+            dirs_exist_ok=True,
+        )
+        # shutil.copytree(os.path.join(self.template_dir, "images"), os.path.join(self.config.path, "images"), dirs_exist_ok=True)
+        # shutil.copytree(os.path.join(self.template_dir, "fonts"), os.path.join(self.config.path, "fonts"), dirs_exist_ok=True)
+
+        # render templates
+        git_stats_data = {}
+        if metrics.git_metrics:
+            git_stats_data = metrics.git_metrics.get_commit_stats_per_month()
+
+        self.output.writeln("<info>Rendering index page</info>")
+        # Render main index page
+        self.render_template(
+            "index.html",
+            {
+                "git_stats_data": json.dumps(git_stats_data, indent=4),
+                "total_code_metrics": metrics.total_code_metrics.to_dict(),
+                "segmentation_data": json.dumps(
+                    metrics.total_code_metrics.to_dict_segmentation(), indent=4
+                ),
+                "project_name": "CodeMetrics",
+                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "author": "CodeMetrics",
+                "version": "1.0.0",
+            },
+        )
+        self.output.writeln("<success>Done rendering index page</success>")
+
+        # Render files page
+        self.render_files_page(metrics)
+        # Render git analysis page
+        self.render_git_analysis_page(metrics)
+
+        self.render_dependencies_page(metrics)
+
+        self.output.writeln(
+            f"<success>HTML report generated in {self.config.path} directory</success>"
+        )
+
+    def render_template(self, template_name: str, data: dict) -> str:
+        engine = TemplateEngine(os.path.join(self.template_dir, template_name))
+        content = engine.render(**data)
+        with open(os.path.join(self.config.path, template_name), "w") as file:
+            file.write(content)
+
+    def render_dependencies_page(self, metrics: ProjectMetrics):
+        """Render the dependencies page with dependency details and stats"""
+        if not metrics.dependencies:
+            self.output.writeln("<success>No dependencies to render</success>")
+            return
+
+        self.output.writeln("<info>Rendering dependencies page</info>")
+
+        dependencies = metrics.dependencies if metrics.dependencies is not None else []
+
+        license_by_type = {}
+
+        # TODO render a pie chart
+        for dependency in dependencies:
+            for license_name in dependency.license:
+                if license_name not in license_by_type.keys():
+                    license_by_type[license_name] = 0
+                license_by_type[license_name] += 1
+
+        print(json.dumps(license_by_type, indent=2))
+
+        self.render_template(
+            "dependencies.html",
+            {
+                "dependencies": [d.to_dict() for d in dependencies],
+                "project_name": "CodeMetrics",
+                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            },
+        )
+        self.output.writeln(
+            "<success>Dependencies page generated successfully</success>"
+        )
+
+    def render_files_page(self, metrics: ProjectMetrics):
+        """Render the files page with file details and analysis"""
+        self.output.writeln("<info>Rendering files page</info>")
+
+        file_names = []
+        file_details = {}
+        for file_metrics in metrics.file_metrics:
+            file_name = file_metrics.full_name
+            file_details[file_name] = file_metrics.to_dict()
+            file_names.append(file_name)
+
+        filetree = FileTreeParser.parse(file_names, shorten=True)
+
+        self.render_template(
+            "files.html",
+            {
+                "filetree": json.dumps(filetree.to_dict()),
+                "file_details": json.dumps(file_details),
+                "project_name": "CodeMetrics",
+                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            },
+        )
+        self.output.writeln("<success>Files page generated successfully</success>")
+
+    def render_git_analysis_page(self, metrics: ProjectMetrics):
+        """Render the git analysis page with comprehensive git data"""
+        if not metrics.git_metrics:
+            self.output.writeln("<success>No git metrics to render</success>")
+            return
+
+        def stringify_values(obj):
+            if isinstance(obj, dict):
+                return {key: stringify_values(value) for key, value in obj.items()}
+            elif isinstance(obj, list):
+                return [stringify_values(item) for item in obj]
+            else:
+                return str(obj)
+
+        self.output.writeln("<info>Rendering git analysis page</info>")
+        try:
+            # Render git analysis template
+            self.render_template(
+                "git_analysis.html",
+                stringify_values(
+                    {
+                        "git_analysis": metrics.git_metrics.to_dict(),
+                        "git_analysis_json": json.dumps(
+                            metrics.git_metrics.get_contributors_dict(), indent=4
+                        ),
+                        "git_stats_data": json.dumps(
+                            metrics.git_metrics.get_commit_stats_per_month(), indent=4
+                        ),  # git commit graph
+                        "git_churn_data": json.dumps(
+                            metrics.git_metrics.get_churn_per_month(), indent=4
+                        ),  # git chrun graph
+                        "git_silos_data": metrics.git_metrics.get_silos_list()[
+                            :10
+                        ],  # silos list
+                        "git_contributors": metrics.git_metrics.get_contributors_list()[
+                            :10
+                        ],  # contributors list
+                        "git_hotspots_data": metrics.git_metrics.get_hotspots_list()[
+                            :10
+                        ],  # hotspots list
+                        "project_name": "CodeMetrics",
+                        "last_updated": metrics.git_metrics.get_analysis_start_date(),
+                    }
+                ),
+            )
+
+            self.output.writeln(
+                "<success>Git analysis page generated successfully</success>"
+            )
+        except Exception as e:
+            raise e
+            self.output.writeln(
+                f"<error>Error generating git analysis page: {e}</error>"
+            )

metripy/Report/Json/AbstractJsonReporter.py

@@ -0,0 +1,11 @@
+import json
+import os
+
+from metripy.Report.ReporterInterface import ReporterInterface
+
+
+class AbstractJsonReporter(ReporterInterface):
+    def put_data(self, data: dict) -> None:
+        os.makedirs(os.path.dirname(self.config.path), exist_ok=True)
+        with open(self.config.path, "w") as file:
+            json.dump(data, file, indent=2)

metripy/Report/Json/GitJsonReporter.py

@@ -0,0 +1,21 @@
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Json.AbstractJsonReporter import AbstractJsonReporter
+
+
+class GitJsonReporter(AbstractJsonReporter):
+    def generate(self, metrics: ProjectMetrics) -> None:
+        if not metrics.git_metrics:
+            self.output.writeln(
+                "<error>Wants git json report, but no git metrics</error>"
+            )
+            return
+
+        data = {
+            "commits_per_month": metrics.git_metrics.get_commit_stats_per_month(),
+            "churn_data": metrics.git_metrics.get_churn_per_month(),
+            "possible_silos": metrics.git_metrics.get_silos_list()[:10],
+            "top_contributors": metrics.git_metrics.get_contributors_list()[:10],
+            "top_hotspots": metrics.git_metrics.get_hotspots_list()[:10],
+        }
+
+        self.put_data(data)

metripy/Report/Json/JsonReporter.py

@@ -0,0 +1,12 @@
+from metripy.Application.Config.Config import Config
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class JsonReporter:
+    def __init__(self, config: Config, output: CliOutput):
+        self.config = config
+        self.output = output
+
+    def generate(self, metrics: ProjectMetrics):
+        raise NotImplementedError

metripy/Report/ReporterFactory.py

@@ -0,0 +1,22 @@
+from metripy.Application.Config.ReportConfig import ReportConfig
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Report import ReporterInterface
+from metripy.Report.Html.Reporter import Reporter as HtmlReporter
+from metripy.Report.Json.GitJsonReporter import GitJsonReporter
+
+
+class ReporterFactory:
+    @staticmethod
+    def create(config: ReportConfig, output: CliOutput) -> ReporterInterface:
+        if config.type == "html":
+            return HtmlReporter(config, output)
+        elif config.type == "json":
+            raise NotImplementedError
+        elif config.type == "csv":
+            raise NotImplementedError
+        elif config.type == "cli":
+            raise NotImplementedError
+        elif config.type == "json-git":
+            return GitJsonReporter(config, output)
+        else:
+            raise ValueError(f"Unsupported report type: {config.type}")

metripy/Report/ReporterInterface.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from metripy.Application.Config.ReportConfig import ReportConfig
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class ReporterInterface(ABC):
+    def __init__(
+        self, config: ReportConfig, output: CliOutput, project_name: str = "foobar"
+    ):
+        self.config: ReportConfig = config
+        self.output = output
+
+    @abstractmethod
+    def generate(self, metrics: ProjectMetrics) -> None:
+        raise NotImplementedError()

metripy/Tree/ClassNode.py

@@ -0,0 +1,32 @@
+from metripy.Tree.FunctionNode import FunctionNode
+
+
+class ClassNode:
+    def __init__(
+        self,
+        full_name: str,
+        name: str,
+        lineno: int,
+        col_offset: int,
+        real_complexity: int,
+    ):
+        self.full_name = full_name
+        self.name = name
+        self.lineno = lineno
+        self.col_offset = col_offset
+        self.real_complexity = real_complexity
+        self.functions: list[FunctionNode] = []
+
+    def to_dict(self) -> dict:
+        """Convert ClassNode to a dictionary for JSON serialization."""
+        return {
+            "full_name": self.full_name,
+            "name": self.name,
+            "lineno": self.lineno,
+            "col_offset": self.col_offset,
+            "real_complexity": self.real_complexity,
+            "functions": [func.to_dict() for func in self.functions],
+        }
+
+    def __dict__(self) -> dict:
+        return self.to_dict()

metripy/Tree/FunctionNode.py

@@ -0,0 +1,49 @@
+class FunctionNode:
+    def __init__(
+        self, full_name: str, name: str, lineno: int, col_offset: int, complexity: int
+    ):
+        self.full_name = full_name
+        self.name = name
+        self.lineno = lineno
+        self.line_end = 0
+        self.col_offset = col_offset
+        self.complexity = complexity
+        self.h1 = 0
+        self.h2 = 0
+        self.N1 = 0
+        self.N2 = 0
+        self.vocabulary = 0
+        self.length = 0
+        self.calculated_length = 0
+        self.volume = 0
+        self.difficulty = 0
+        self.effort = 0
+        self.time = 0
+        self.bugs = 0
+        self.maintainability_index = 0
+
+    def to_dict(self) -> dict:
+        """Convert FunctionNode to a dictionary for JSON serialization."""
+        return {
+            "full_name": self.full_name,
+            "name": self.name,
+            "lineno": self.lineno,
+            "col_offset": self.col_offset,
+            "complexity": self.complexity,
+            "h1": self.h1,
+            "h2": self.h2,
+            "N1": self.N1,
+            "N2": self.N2,
+            "vocabulary": self.vocabulary,
+            "length": self.length,
+            "calculated_length": self.calculated_length,
+            "volume": self.volume,
+            "difficulty": self.difficulty,
+            "effort": self.effort,
+            "time": self.time,
+            "bugs": self.bugs,
+            "maintainability_index": self.maintainability_index,
+        }
+
+    def __dict__(self) -> dict:
+        return self.to_dict()

metripy/Tree/ModuleNode.py

@@ -0,0 +1,42 @@
+from metripy.Tree.ClassNode import ClassNode
+from metripy.Tree.FunctionNode import FunctionNode
+
+
+class ModuleNode:
+    def __init__(
+        self,
+        full_name: str,
+        loc: int,
+        lloc: int,
+        sloc: int,
+        comments: int,
+        multi: int,
+        blank: int,
+        single_comments: int,
+    ):
+        self.full_name = full_name
+        self.loc = loc
+        self.lloc = lloc
+        self.sloc = sloc
+        self.comments = comments
+        self.multi = multi
+        self.blank = blank
+        self.single_comments = single_comments
+        self.maintainability_index = 0
+        self.classes: list[ClassNode] = []
+        self.functions: list[FunctionNode] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "full_name": self.full_name,
+            "loc": self.loc,
+            "lloc": self.lloc,
+            "sloc": self.sloc,
+            "comments": self.comments,
+            "multi": self.multi,
+            "blank": self.blank,
+            "single_comments": self.single_comments,
+            "maintainability_index": self.maintainability_index,
+            "classes": [c.to_dict() for c in self.classes],
+            "functions": [f.to_dict() for f in self.functions],
+        }

metripy/metripy.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""main module"""
+import sys
+
+from metripy.Application.Application import Application
+
+
+def main():
+    """cli entry point to application"""
+    application = Application()
+    application.run(sys.argv)
+
+
+if __name__ == "__main__":
+    main()