metripy 0.2.5__py3-none-any.whl

src/Metric/Code/SegmentedMetrics.py

@@ -0,0 +1,65 @@
+from typing import Self
+
+
+class SegmentedMetrics:
+    def __init__(self):
+        self.good = 0
+        self.ok = 0
+        self.warning = 0
+        self.critical = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
+
+    def set_loc(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 200:
+                self.good += 1
+            elif value <= 500:
+                self.ok += 1
+            elif value <= 1000:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self
+
+    def set_complexity(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 5:
+                self.good += 1
+            elif value <= 10:
+                self.ok += 1
+            elif value <= 20:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self
+
+    def set_maintainability(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 80:
+                self.critical += 1
+            elif value <= 60:
+                self.warning += 1
+            elif value <= 40:
+                self.ok += 1
+            else:
+                self.good += 1
+        return self
+
+    def set_method_size(self, values: list[int]) -> Self:
+        for value in values:
+            if value <= 15:
+                self.good += 1
+            elif value <= 30:
+                self.ok += 1
+            elif value <= 50:
+                self.warning += 1
+            else:
+                self.critical += 1
+        return self

src/Metric/FileTree/FileTree.py

@@ -0,0 +1,15 @@
+from typing import Self
+
+
+class FileTree:
+    def __init__(self, name: str, full_name: str, children: list[Self] | None = None):
+        self.name = name
+        self.full_name = full_name
+        self.children: list[Self] = children if children is not None else []
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "full_name": self.full_name,
+            "children": [child.to_dict() for child in self.children],
+        }

src/Metric/FileTree/FileTreeParser.py

@@ -0,0 +1,42 @@
+from Metric.FileTree.FileTree import FileTree
+
+
+class FileTreeParser:
+    @staticmethod
+    def parse(paths: list[str], shorten: bool = False) -> FileTree:
+        root = FileTree(".", ".")
+
+        for path in paths:
+            parts = path.strip("./").split("/")
+            current = root
+
+            for part in parts:
+                # Check if part already exists in current children
+                found = next(
+                    (child for child in current.children if child.name == part), None
+                )
+                if not found:
+                    found = FileTree(part, path)
+                    current.children.append(found)
+                current = found
+
+        if shorten:
+            FileTreeParser._shorten_tree(root)
+
+        return root
+
+    @staticmethod
+    def _shorten_tree(node: FileTree):
+        """shorten tree nodes that only have a single child"""
+        while len(node.children) == 1:
+            child = node.children[0]
+            node.name += "/" + child.name
+            node.full_name = child.full_name
+            node.children = child.children
+
+        for child in node.children:
+            FileTreeParser._shorten_tree(child)
+
+        # print(json.dumps(root.to_dict(), indent=4))
+        # exit()
+        # return root

src/Metric/Git/GitCodeHotspot.py

@@ -0,0 +1,37 @@
+class GitCodeHotspot:
+
+    def __init__(self, file_path: str, changes_count: int, contributors_count: int):
+        self.file_path = file_path
+        self.changes_count = changes_count
+        self.contributors_count = contributors_count
+        self.risk_level = self._calc_risk_level(changes_count, contributors_count)
+        self.risk_label = self._label_from_risk_level()
+
+    def _calc_risk_level(self, changes_count: int, contributors_count: int) -> str:
+        if changes_count < 10:
+            if contributors_count < 5:
+                return "low"
+            else:
+                return "medium"
+        elif changes_count < 50:
+            if contributors_count < 5:
+                return "medium"
+            else:
+                return "high"
+        else:
+            if contributors_count < 1:
+                return "medium"
+            else:
+                return "high"
+
+    def _label_from_risk_level(self) -> str:
+        return self.risk_level.capitalize()
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "file_path": self.file_path,
+            "changes_count": self.changes_count,
+            "risk_level": self.risk_level,
+            "risk_label": self.risk_label,
+            "contributors_count": self.contributors_count,
+        }

src/Metric/Git/GitContributor.py

@@ -0,0 +1,37 @@
+class GitContributor:
+    def __init__(
+        self,
+        name: str,
+        commits_count: int,
+        lines_added: int,
+        lines_removed: int,
+        contribution_percentage: int,
+    ):
+        self.name = name
+        self.initials = self._get_initials(name)
+        self.commits_count = commits_count
+        self.lines_added = lines_added
+        self.lines_removed = lines_removed
+        self.contribution_percentage = contribution_percentage
+
+    def _get_initials(self, name: str) -> str:
+        try:
+            parts = name.split()
+            if len(parts) >= 2:
+                return (parts[0][0] + parts[1][0]).upper()
+            elif len(parts) == 1:
+                return parts[0][:2].upper()
+            else:
+                return "UN"
+        except Exception:
+            return "UN"
+
+    def to_dict(self) -> dict[str, int]:
+        return {
+            "name": self.name,
+            "initials": self.initials,
+            "commits_count": self.commits_count,
+            "lines_added": self.lines_added,
+            "lines_removed": self.lines_removed,
+            "contribution_percentage": self.contribution_percentage,
+        }

src/Metric/Git/GitKnowledgeSilo.py

@@ -0,0 +1,27 @@
+class GitKnowledgeSilo:
+    def __init__(self, file_path: str, owner: str, commits_count: int):
+        self.file_path = file_path
+        self.owner = owner
+        self.commits_count = commits_count
+        self.risk_level = self._calc_risk_level(commits_count)
+        self.risk_label = self._calc_risk_label(self.risk_level)
+
+    def _calc_risk_level(self, commits_count: int) -> str:
+        if commits_count >= 15:
+            return "high"
+        elif commits_count >= 8:
+            return "medium"
+        else:
+            return "low"
+
+    def _calc_risk_label(self, risk_level: str) -> str:
+        return risk_level.capitalize()
+
+    def to_dict(self) -> dict[str, int]:
+        return {
+            "file_path": f"{self.file_path}",
+            "owner": f"{self.owner}",
+            "commits_count": f"{self.commits_count}",
+            "risk_level": f"{self.risk_level}",
+            "risk_label": f"{self.risk_label}",
+        }

src/Metric/Git/GitMetrics.py

@@ -0,0 +1,148 @@
+from Metric.Git.GitCodeHotspot import GitCodeHotspot
+from Metric.Git.GitContributor import GitContributor
+from 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(),
+        }

src/Metric/ProjectMetrics.py

@@ -0,0 +1,55 @@
+from Dependency.Dependency import Dependency
+from Metric.Code.AggregatedMetrics import AggregatedMetrics
+from Metric.Code.FileMetrics import FileMetrics
+from Metric.Code.SegmentedMetrics import SegmentedMetrics
+from 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)

src/Report/Csv/Reporter.py

@@ -0,0 +1,12 @@
+from Application.Config.Config import Config
+from Component.Output.CliOutput import CliOutput
+from 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")

src/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 Application.Config.ReportConfig import ReportConfig
+from Component.Output.CliOutput import CliOutput
+from Metric.FileTree.FileTreeParser import FileTreeParser
+from Metric.ProjectMetrics import ProjectMetrics
+from 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>"
+            )

src/Report/Json/AbstractJsonReporter.py

@@ -0,0 +1,10 @@
+from Report.ReporterInterface import ReporterInterface
+import json
+import os
+
+
+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)