metripy 0.2.7__py3-none-any.whl → 0.3.6__py3-none-any.whl

metripy/Metric/Trend/AggregatedTrendMetric.py

@@ -0,0 +1,101 @@
+from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+from metripy.Metric.Trend.SegmentedTrendMetric import SegmentedTrendMetric
+
+
+class AggregatedTrendMetric:
+    def __init__(
+        self,
+        historical_loc: int,
+        loc: int,
+        historical_avgCcPerFunction: float,
+        avgCcPerFunction: float,
+        historical_maintainabilityIndex: float,
+        maintainabilityIndex: float,
+        historical_avgLocPerFunction: float,
+        avgLocPerFunction: float,
+        historical_num_files: int,
+        num_files: int,
+        historical_segmented_loc: SegmentedMetrics,
+        segmented_loc: SegmentedMetrics,
+        historical_segmented_complexity: SegmentedMetrics,
+        segmented_complexity: SegmentedMetrics,
+        historical_segmented_maintainability: SegmentedMetrics,
+        segmented_maintainability: SegmentedMetrics,
+        historical_segmented_method_size: SegmentedMetrics,
+        segmented_method_size: SegmentedMetrics,
+    ):
+        self.historical_loc = historical_loc
+        self.loc_delta = loc - historical_loc
+        self.historical_avgCcPerFunction = historical_avgCcPerFunction
+        self.avgCcPerFunction_delta = avgCcPerFunction - historical_avgCcPerFunction
+        self.historical_maintainabilityIndex = historical_maintainabilityIndex
+        self.maintainabilityIndex_delta = (
+            maintainabilityIndex - historical_maintainabilityIndex
+        )
+        self.historical_avgLocPerFunction = historical_avgLocPerFunction
+        self.avgLocPerFunction_delta = avgLocPerFunction - historical_avgLocPerFunction
+        self.historical_num_files = historical_num_files
+        self.num_files_delta = num_files - historical_num_files
+
+        self.historical_segmentation_data = {
+            "loc": historical_segmented_loc,
+            "complexity": historical_segmented_complexity,
+            "maintainability": historical_segmented_maintainability,
+            "methodSize": historical_segmented_method_size,
+        }
+
+        self.segmentation_data_deltas = {
+            "loc": SegmentedTrendMetric(historical_segmented_loc, segmented_loc),
+            "complexity": SegmentedTrendMetric(
+                historical_segmented_complexity, segmented_complexity
+            ),
+            "maintainability": SegmentedTrendMetric(
+                historical_segmented_maintainability, segmented_maintainability
+            ),
+            "methodSize": SegmentedTrendMetric(
+                historical_segmented_method_size, segmented_method_size
+            ),
+        }
+
+    def get_trend_type(self, delta: float, up_is_good: bool) -> str:
+        if up_is_good:
+            return "positive" if delta > 0 else "negative" if delta < 0 else "neutral"
+        else:
+            return "negative" if delta > 0 else "positive" if delta < 0 else "neutral"
+
+    def get_trend_icon(self, delta: float) -> str:
+        return "arrow-up" if delta > 0 else "arrow-down" if delta < 0 else "arrow-right"
+
+    def to_dict(self) -> dict:
+        return {
+            "loc_delta": round(self.loc_delta, 2),
+            "loc_trend_type": self.get_trend_type(self.loc_delta, False),
+            "loc_trend_icon": self.get_trend_icon(self.loc_delta),
+            "avgCcPerFunction_delta": round(self.avgCcPerFunction_delta, 2),
+            "avgCcPerFunction_trend_type": self.get_trend_type(
+                self.avgCcPerFunction_delta, False
+            ),
+            "avgCcPerFunction_trend_icon": self.get_trend_icon(
+                self.avgCcPerFunction_delta
+            ),
+            "maintainabilityIndex_delta": round(self.maintainabilityIndex_delta, 2),
+            "maintainabilityIndex_trend_type": self.get_trend_type(
+                self.maintainabilityIndex_delta, True
+            ),
+            "maintainabilityIndex_trend_icon": self.get_trend_icon(
+                self.maintainabilityIndex_delta
+            ),
+            "avgLocPerFunction_delta": round(self.avgLocPerFunction_delta, 2),
+            "avgLocPerFunction_trend_type": self.get_trend_type(
+                self.avgLocPerFunction_delta, False
+            ),
+            "avgLocPerFunction_trend_icon": self.get_trend_icon(
+                self.avgLocPerFunction_delta
+            ),
+            "num_files_delta": self.num_files_delta,
+            "num_files_trend_type": self.get_trend_type(self.num_files_delta, False),
+            "num_files_trend_icon": self.get_trend_icon(self.num_files_delta),
+        }
+
+    def to_dict_segmentation(self) -> dict:
+        return {k: v.to_dict() for k, v in self.segmentation_data_deltas.items()}

metripy/Metric/Trend/ClassTrendMetric.py

@@ -0,0 +1,20 @@
+class ClassTrendMetric:
+    def __init__(
+        self,
+        historical_lineno: int,
+        lineno: int,
+        historical_real_complexity: int,
+        real_complexity: int,
+    ):
+        self.historical_lineno = historical_lineno
+        self.lineno_delta = lineno - historical_lineno
+        self.historical_real_complexity = historical_real_complexity
+        self.real_complexity_delta = real_complexity - historical_real_complexity
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_lineno": self.historical_lineno,
+            "lineno_delta": self.lineno_delta,
+            "historical_real_complexity": self.historical_real_complexity,
+            "real_complexity_delta": self.real_complexity_delta,
+        }

metripy/Metric/Trend/FileTrendMetric.py

@@ -0,0 +1,46 @@
+class FileTrendMetric:
+    def __init__(
+        self,
+        historical_loc: int,
+        loc: int,
+        historical_totalCc: int,
+        totalCc: int,
+        historical_avgCcPerFunction: float,
+        avgCcPerFunction: float,
+        historical_maintainabilityIndex: float,
+        maintainabilityIndex: float,
+        historical_avgLocPerFunction: float,
+        avgLocPerFunction: float,
+    ):
+        self.historical_loc = historical_loc
+        self.loc_delta = loc - historical_loc
+
+        self.historical_totalCc = historical_totalCc
+        self.totalCc_delta = totalCc - historical_totalCc
+
+        self.historical_avgCcPerFunction = historical_avgCcPerFunction
+        self.avgCcPerFunction_delta = avgCcPerFunction - historical_avgCcPerFunction
+
+        self.maintainabilityIndex_delta = (
+            maintainabilityIndex - historical_maintainabilityIndex
+        )
+        self.historical_maintainabilityIndex = historical_maintainabilityIndex
+
+        self.avgLocPerFunction_delta = avgLocPerFunction - historical_avgLocPerFunction
+        self.historical_avgLocPerFunction = historical_avgLocPerFunction
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_loc": round(self.historical_loc, 2),
+            "loc_delta": round(self.loc_delta, 2),
+            "historical_totalCc": round(self.historical_totalCc, 2),
+            "totalCc_delta": round(self.totalCc_delta, 2),
+            "historical_avgCcPerFunction": round(self.historical_avgCcPerFunction, 2),
+            "avgCcPerFunction_delta": round(self.avgCcPerFunction_delta, 2),
+            "historical_maintainabilityIndex": round(
+                self.historical_maintainabilityIndex, 2
+            ),
+            "maintainabilityIndex_delta": round(self.maintainabilityIndex_delta, 2),
+            "historical_avgLocPerFunction": round(self.historical_avgLocPerFunction, 2),
+            "avgLocPerFunction_delta": round(self.avgLocPerFunction_delta, 2),
+        }

metripy/Metric/Trend/FunctionTrendMetric.py

@@ -0,0 +1,28 @@
+class FunctionTrendMetric:
+    def __init__(
+        self,
+        historical_loc: int,
+        loc: int,
+        historical_complexity: int,
+        complexity: int,
+        historical_maintainability_index: float,
+        maintainability_index: float,
+    ):
+        self.historical_loc = historical_loc
+        self.loc_delta = loc - historical_loc
+        self.historical_complexity = historical_complexity
+        self.complexity_delta = complexity - historical_complexity
+        self.historical_maintainability_index = historical_maintainability_index
+        self.maintainability_index_delta = (
+            maintainability_index - historical_maintainability_index
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_loc": self.historical_loc,
+            "loc_delta": self.loc_delta,
+            "historical_complexity": self.historical_complexity,
+            "complexity_delta": self.complexity_delta,
+            "historical_maintainability_index": self.historical_maintainability_index,
+            "maintainability_index_delta": self.maintainability_index_delta,
+        }

metripy/Metric/Trend/SegmentedTrendMetric.py

@@ -0,0 +1,29 @@
+from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+
+
+class SegmentedTrendMetric:
+    def __init__(
+        self,
+        historical_segmentation: SegmentedMetrics,
+        segmentation: SegmentedMetrics,
+    ):
+        self.historical_good = historical_segmentation.good
+        self.good_delta = segmentation.good - historical_segmentation.good
+        self.historical_ok = historical_segmentation.ok
+        self.ok_delta = segmentation.ok - historical_segmentation.ok
+        self.historical_warning = historical_segmentation.warning
+        self.warning_delta = segmentation.warning - historical_segmentation.warning
+        self.historical_critical = historical_segmentation.critical
+        self.critical_delta = segmentation.critical - historical_segmentation.critical
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_good": self.historical_good,
+            "good_delta": self.good_delta,
+            "historical_ok": self.historical_ok,
+            "ok_delta": self.ok_delta,
+            "historical_warning": self.historical_warning,
+            "warning_delta": self.warning_delta,
+            "historical_critical": self.historical_critical,
+            "critical_delta": self.critical_delta,
+        }

metripy/Report/Html/DependencyPageRenderer.py

@@ -0,0 +1,21 @@
+from metripy.Dependency.Dependency import Dependency
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+import json
+
+class DependencyPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        dependencies = metrics.dependencies if metrics.dependencies is not None else []
+        license_by_type = Dependency.get_lisence_distribution(dependencies)
+
+        self.render_template(
+            "dependencies.html",
+            {
+                "has_dependencies_data": bool(metrics.dependencies),
+                "dependencies": [d.to_dict() for d in dependencies],
+                "license_distribution_json": json.dumps(license_by_type, indent=2),
+            },
+        )

metripy/Report/Html/FilesPageRenderer.py

@@ -0,0 +1,28 @@
+import json
+
+from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class FilesPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        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),
+            },
+        )

metripy/Report/Html/GitAnalysisPageRenderer.py

@@ -0,0 +1,55 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class GitAnalysisPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def _render_empty_template(self):
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": False,
+                "git_analysis": {},
+                "git_analysis_json": "{}",
+                "git_stats_data": "{}",
+                "git_churn_data": "{}",
+                "git_silos_data": [],
+                "git_contributors": [],
+                "git_hotspots_data": [],
+            },
+        )
+
+    def render(self, metrics: ProjectMetrics):
+        if not metrics.git_metrics:
+            self._render_empty_template()
+            return
+
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": bool(metrics.git_metrics),
+                "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
+            },
+        )

metripy/Report/Html/IndexPageRenderer.py

@@ -0,0 +1,47 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+from metripy.Dependency.Dependency import Dependency
+
+
+class IndexPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        git_stats_data = {}
+        if metrics.git_metrics:
+            git_stats_data = metrics.git_metrics.get_commit_stats_per_month()
+
+
+        dependencies = metrics.dependencies if metrics.dependencies is not None else []
+        license_by_type = Dependency.get_lisence_distribution(dependencies)
+
+        self.render_template(
+            "index.html",
+            {
+                "git_stats_data": json.dumps(git_stats_data, indent=4),
+                "license_distribution_json": json.dumps(license_by_type, indent=2),
+                "total_code_metrics": metrics.total_code_metrics.to_dict(),
+                "has_total_code_metrics_trend": metrics.total_code_metrics.trend
+                is not None,
+                "total_code_metrics_trend": (
+                    metrics.total_code_metrics.trend.to_dict()
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+                "segmentation_data": json.dumps(
+                    metrics.total_code_metrics.to_dict_segmentation(), indent=4
+                ),
+                "segmentation_data_trend": (
+                    json.dumps(
+                        metrics.total_code_metrics.trend.to_dict_segmentation(),
+                        indent=4,
+                    )
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+            },
+        )

metripy/Report/Html/PageRenderer.py

@@ -0,0 +1,43 @@
+import os
+from datetime import datetime
+
+from py_template_engine import TemplateEngine
+
+from metripy.Application.Info import Info
+
+
+class PageRenderer:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+
+        self.global_template_args = {
+            "project_name": project_name,
+            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "author": "Metripy",
+            "version": Info().get_version(),
+        }
+
+    @staticmethod
+    def _stringify_values(obj):
+        if isinstance(obj, dict):
+            return {
+                key: PageRenderer._stringify_values(value) for key, value in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [PageRenderer._stringify_values(item) for item in obj]
+        else:
+            return str(obj)
+
+    def render_template(self, template_name: str, data: dict):
+        data = self._stringify_values(
+            {
+                **self.global_template_args,
+                **data,
+            }
+        )
+        engine = TemplateEngine(os.path.join(self.template_dir, template_name))
+        content = engine.render(**data)
+        with open(os.path.join(self.output_dir, template_name), "w") as file:
+            file.write(content)

metripy/Report/Html/PageRendererFactory.py

@@ -0,0 +1,37 @@
+from metripy.Report.Html.DependencyPageRenderer import DependencyPageRenderer
+from metripy.Report.Html.FilesPageRenderer import FilesPageRenderer
+from metripy.Report.Html.GitAnalysisPageRenderer import GitAnalysisPageRenderer
+from metripy.Report.Html.IndexPageRenderer import IndexPageRenderer
+from metripy.Report.Html.TopOffendersPageRenderer import TopOffendersPageRenderer
+from metripy.Report.Html.TrendsPageRenderer import TrendsPageRenderer
+
+
+class PageRendererFactory:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+        self.project_name = project_name
+
+    def create_index_page_renderer(self) -> IndexPageRenderer:
+        return IndexPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_files_page_renderer(self) -> FilesPageRenderer:
+        return FilesPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_top_offenders_page_renderer(self) -> TopOffendersPageRenderer:
+        return TopOffendersPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_git_analysis_page_renderer(self) -> GitAnalysisPageRenderer:
+        return GitAnalysisPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_dependency_page_renderer(self) -> DependencyPageRenderer:
+        return DependencyPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_trends_page_renderer(self) -> TrendsPageRenderer:
+        return TrendsPageRenderer(self.template_dir, self.output_dir, self.project_name)