metripy 0.2.8__py3-none-any.whl → 0.3.0__py3-none-any.whl

metripy/Report/Html/Reporter.py

@@ -7,10 +7,12 @@ from py_template_engine import TemplateEngine
 
 from metripy.Application.Config.ReportConfig import ReportConfig
 from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Dependency.Dependency import Dependency
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.Code.Segmentor import Segmentor
 from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
 from metripy.Metric.ProjectMetrics import ProjectMetrics
 from metripy.Report.ReporterInterface import ReporterInterface
-from metripy.Dependency.Dependency import Dependency
 
 
 class Reporter(ReporterInterface):
@@ -54,24 +56,173 @@ class Reporter(ReporterInterface):
             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, "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
+        # copy logo, lies 2 down from the templates directory
+        shutil.copy(os.path.join(self.template_dir, "../..", "logo.svg"), os.path.join(self.config.path, "images", "logo.svg"))
+
+        # Render main pages
+        self.render_index_page(metrics)
+        self.render_files_page(metrics)
+        self.render_git_analysis_page(metrics)
+        self.render_dependencies_page(metrics)
+        self.render_top_offenders_page(metrics)
+        self.render_trends_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_trends_page(self, metrics: ProjectMetrics):
+        def compile(file: FileMetrics) -> dict:
+            return {
+                "name": file.full_name,
+                "path": file.full_name,
+                "complexity_current": file.totalCc,
+                "complexity_prev": round(file.trend.historical_totalCc, 2),
+                "complexity_delta": round(file.trend.totalCc_delta, 2),
+                "maintainability_current": round(file.maintainabilityIndex, 2),
+                "maintainability_prev": round(
+                    file.trend.historical_maintainabilityIndex, 2
+                ),
+                "maintainability_delta": round(
+                    file.trend.maintainabilityIndex_delta, 2
+                ),
+            }
+
+        # Top improved complexity (complexity went down - negative delta)
+        top_improved_complexity = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and x.trend.totalCc_delta < 0
+        ]
+        top_improved_complexity = sorted(
+            top_improved_complexity, key=lambda x: x.trend.totalCc_delta
+        )[:10]
+
+        # Top worsened complexity (complexity went up - positive delta)
+        top_worsened_complexity = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and x.trend.totalCc_delta > 0
+        ]
+        top_worsened_complexity = sorted(
+            top_worsened_complexity, key=lambda x: x.trend.totalCc_delta, reverse=True
+        )[:10]
+
+        # Top improved maintainability (maintainability went up - positive delta)
+        top_improved_maintainability = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and round(x.trend.maintainabilityIndex_delta, 2) > 0
+        ]
+        top_improved_maintainability = sorted(
+            top_improved_maintainability,
+            key=lambda x: x.trend.maintainabilityIndex_delta,
+            reverse=True,
+        )[:10]
+
+        # Top worsened maintainability (maintainability went down - negative delta)
+        top_worsened_maintainability = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and round(x.trend.maintainabilityIndex_delta, 2) < 0
+        ]
+        top_worsened_maintainability = sorted(
+            top_worsened_maintainability,
+            key=lambda x: x.trend.maintainabilityIndex_delta,
+        )[:10]
+
+        trend_data = {
+            # Segment distributions for each metric
+            "loc_segments_current": metrics.total_code_metrics.segmentation_data[
+                "loc"
+            ].to_dict_with_percent(),
+            "loc_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "loc"
+            ].to_dict_with_percent(),
+            "complexity_segments_current": metrics.total_code_metrics.segmentation_data[
+                "complexity"
+            ].to_dict_with_percent(),
+            "complexity_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "complexity"
+            ].to_dict_with_percent(),
+            "maintainability_segments_current": metrics.total_code_metrics.segmentation_data[
+                "maintainability"
+            ].to_dict_with_percent(),
+            "maintainability_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "maintainability"
+            ].to_dict_with_percent(),
+            "method_size_segments_current": metrics.total_code_metrics.segmentation_data[
+                "methodSize"
+            ].to_dict_with_percent(),
+            "method_size_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "methodSize"
+            ].to_dict_with_percent(),
+            "top_improved_complexity": [compile(x) for x in top_improved_complexity],
+            "top_improved_maintainability": [
+                compile(x) for x in top_improved_maintainability
+            ],
+            "top_worsened_complexity": [compile(x) for x in top_worsened_complexity],
+            "top_worsened_maintainability": [
+                compile(x) for x in top_worsened_maintainability
+            ],
+        }
+
+        self.output.writeln("<info>Rendering trends page</info>")
+        self.render_template(
+            "trends.html",
+            {
+                "has_trend_data": metrics.total_code_metrics.trend is not None,
+                "trend_data": trend_data,
+                "project_name": "Metripy",
+                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "author": "Metripy",
+                "version": "1.0.0",
+            },
+        )
+
+    def render_index_page(self, metrics: ProjectMetrics):
         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(),
+                "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
+                ),
                 "project_name": "Metripy",
                 "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                 "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
@@ -81,23 +232,91 @@ class Reporter(ReporterInterface):
         )
         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)
+    def render_top_offenders_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering top offenders page</info>")
 
-        self.render_dependencies_page(metrics)
+        orderedByTotalCc = sorted(
+            metrics.file_metrics, key=lambda x: x.totalCc, reverse=True
+        )[:10]
+        orderedByMI = sorted(
+            metrics.file_metrics, key=lambda x: x.maintainabilityIndex, reverse=False
+        )[:10]
+        orderedByLoc = sorted(metrics.file_metrics, key=lambda x: x.loc, reverse=True)[
+            :10
+        ]
+
+        all_functions: list = []
+        for fm in metrics.file_metrics:
+            all_functions.extend(fm.function_nodes)
 
+        functionsOrderedByCc = sorted(
+            all_functions, key=lambda x: x.complexity, reverse=True
+        )[:10]
+        functionsOrderedByMi = sorted(
+            all_functions, key=lambda x: x.maintainability_index, reverse=False
+        )[:10]
+        functionsOrderedByLoc = sorted(
+            all_functions, key=lambda x: x.get_loc(), reverse=True
+        )[:10]
+
+        # TODO maintainability index per function, we dont calc yet
+
+        self.render_template(
+            "top_offenders.html",
+            Reporter._stringify_values(
+                {
+                    "file_loc_offenders": [
+                        {**e.to_dict(), "status": Segmentor.get_loc_segment(e.loc)}
+                        for e in orderedByLoc
+                    ],
+                    "file_cc_offenders": [
+                        {
+                            **e.to_dict(),
+                            "status": Segmentor.get_complexity_segment(e.totalCc),
+                        }
+                        for e in orderedByTotalCc
+                    ],
+                    "file_mi_offenders": [
+                        {
+                            **e.to_dict(),
+                            "status": Segmentor.get_maintainability_segment(
+                                e.maintainabilityIndex
+                            ),
+                        }
+                        for e in orderedByMI
+                    ],
+                    "function_size_offenders": [
+                        {
+                            **e.to_dict(),
+                            "status": Segmentor.get_method_size_segment(e.get_loc()),
+                        }
+                        for e in functionsOrderedByLoc
+                    ],
+                    "function_cc_offenders": [
+                        {
+                            **e.to_dict(),
+                            "status": Segmentor.get_complexity_segment(e.complexity),
+                        }
+                        for e in functionsOrderedByCc
+                    ],
+                    "function_mi_offenders": [
+                        {
+                            **e.to_dict(),
+                            "status": Segmentor.get_maintainability_segment(
+                                e.maintainability_index
+                            ),
+                        }
+                        for e in functionsOrderedByMi
+                    ],
+                    "project_name": "Metripy",
+                    "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                }
+            ),
+        )
         self.output.writeln(
-            f"<success>HTML report generated in {self.config.path} directory</success>"
+            "<success>Top offenders page generated successfully</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:
@@ -108,11 +327,8 @@ class Reporter(ReporterInterface):
 
         dependencies = metrics.dependencies if metrics.dependencies is not None else []
 
-        # TODO render a pie chart
         license_by_type = Dependency.get_lisence_distribution(dependencies)
 
-        print(json.dumps(license_by_type, indent=2))
-
         self.render_template(
             "dependencies.html",
             {
@@ -149,26 +365,29 @@ class Reporter(ReporterInterface):
         )
         self.output.writeln("<success>Files page generated successfully</success>")
 
+    @staticmethod
+    def _stringify_values(obj):
+        if isinstance(obj, dict):
+            return {
+                key: Reporter._stringify_values(value) for key, value in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [Reporter._stringify_values(item) for item in obj]
+        else:
+            return str(obj)
+
     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(
+                Reporter._stringify_values(
                     {
                         "git_analysis": metrics.git_metrics.to_dict(),
                         "git_analysis_json": json.dumps(

metripy/Report/Json/GitJsonReporter.py

@@ -19,4 +19,6 @@ class GitJsonReporter(AbstractJsonReporter):
         }
 
         self.put_data(data)
-        self.output.writeln(f"<success>Create git json report in {self.config.path}</success>")
+        self.output.writeln(
+            f"<success>Create git json report in {self.config.path}</success>"
+        )

metripy/Report/Json/JsonReporter.py

@@ -3,6 +3,7 @@ from metripy.Component.Output.CliOutput import CliOutput
 from metripy.Metric.ProjectMetrics import ProjectMetrics
 from metripy.Report.Json.AbstractJsonReporter import AbstractJsonReporter
 
+
 class JsonReporter(AbstractJsonReporter):
     def __init__(self, config: Config, output: CliOutput):
         self.config = config
@@ -10,4 +11,6 @@ class JsonReporter(AbstractJsonReporter):
 
     def generate(self, metrics: ProjectMetrics):
         self.put_data(metrics.to_dict())
-        self.output.writeln(f"<success>Create json report in {self.config.path}</success>")
+        self.output.writeln(
+            f"<success>Create json report in {self.config.path}</success>"
+        )

metripy/Tree/ClassNode.py

@@ -1,3 +1,7 @@
+from typing import Self
+
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.Trend.ClassTrendMetric import ClassTrendMetric
 from metripy.Tree.FunctionNode import FunctionNode
 
 
@@ -17,6 +21,8 @@ class ClassNode:
         self.real_complexity = real_complexity
         self.functions: list[FunctionNode] = []
 
+        self.trend: ClassTrendMetric | None = None
+
     def to_dict(self) -> dict:
         """Convert ClassNode to a dictionary for JSON serialization."""
         return {
@@ -25,8 +31,23 @@ class ClassNode:
             "lineno": self.lineno,
             "col_offset": self.col_offset,
             "real_complexity": self.real_complexity,
+            "complexity_segment": Segmentor.get_complexity_segment(
+                self.real_complexity
+            ),
             "functions": [func.to_dict() for func in self.functions],
         }
 
     def __dict__(self) -> dict:
         return self.to_dict()
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        node = ClassNode(
+            full_name=data["full_name"],
+            name=data["name"],
+            lineno=data["lineno"],
+            col_offset=data["col_offset"],
+            real_complexity=data["real_complexity"],
+        )
+        node.functions = [FunctionNode.from_dict(d) for d in data["functions"]]
+        return node

metripy/Tree/FunctionNode.py

@@ -1,3 +1,10 @@
+import math
+from typing import Self
+
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.Trend.FunctionTrendMetric import FunctionTrendMetric
+
+
 class FunctionNode:
     def __init__(
         self, full_name: str, name: str, lineno: int, col_offset: int, complexity: int
@@ -21,6 +28,35 @@ class FunctionNode:
         self.time = 0
         self.bugs = 0
         self.maintainability_index = 0
+        self.trend: FunctionTrendMetric | None = None
+
+    def get_loc(self) -> int:
+        return self.line_end - self.lineno
+
+    def calc_mi(self):
+
+        total_volume = self.volume
+        total_complexity = self.complexity
+        total_length = self.length
+
+        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,
+        )
+
+        # no comment weight
+        self.maintainability_index = mi_base
 
     def to_dict(self) -> dict:
         """Convert FunctionNode to a dictionary for JSON serialization."""
@@ -28,8 +64,12 @@ class FunctionNode:
             "full_name": self.full_name,
             "name": self.name,
             "lineno": self.lineno,
+            "line_end": self.line_end,
+            "loc": self.get_loc(),
+            "loc_segment": Segmentor.get_loc_segment(self.get_loc()),
             "col_offset": self.col_offset,
             "complexity": self.complexity,
+            "complexity_segment": Segmentor.get_complexity_segment(self.complexity),
             "h1": self.h1,
             "h2": self.h2,
             "N1": self.N1,
@@ -42,8 +82,33 @@ class FunctionNode:
             "effort": self.effort,
             "time": self.time,
             "bugs": self.bugs,
-            "maintainability_index": self.maintainability_index,
+            "maintainability_index": round(self.maintainability_index, 2),
+            "maintainability_segment": Segmentor.get_maintainability_segment(
+                self.maintainability_index
+            ),
         }
 
     def __dict__(self) -> dict:
         return self.to_dict()
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        node = FunctionNode(
+            full_name=data["full_name"],
+            name=data["name"],
+            lineno=data["lineno"],
+            col_offset=data["col_offset"],
+            complexity=data["complexity"],
+        )
+        node.line_end = data["line_end"]
+        node.vocabulary = data["vocabulary"]
+        node.length = data["length"]
+        node.calculated_length = data["calculated_length"]
+        node.volume = data["volume"]
+        node.difficulty = data["difficulty"]
+        node.effort = data["effort"]
+        node.time = data["time"]
+        node.bugs = data["bugs"]
+        node.maintainability_index = data["maintainability_index"]
+
+        return node

metripy/Trend/TrendAnalyzer.py

@@ -0,0 +1,150 @@
+from metripy.Metric.Code.AggregatedMetrics import AggregatedMetrics
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Metric.Trend.AggregatedTrendMetric import AggregatedTrendMetric
+from metripy.Metric.Trend.ClassTrendMetric import ClassTrendMetric
+from metripy.Metric.Trend.FileTrendMetric import FileTrendMetric
+from metripy.Metric.Trend.FunctionTrendMetric import FunctionTrendMetric
+from metripy.Tree.ClassNode import ClassNode
+from metripy.Tree.FunctionNode import FunctionNode
+
+
+class TrendAnalyzer:
+    def create_file_trend_metric(
+        self, file_metric: FileMetrics, historical_file_metric: FileMetrics
+    ) -> FileTrendMetric:
+        return FileTrendMetric(
+            historical_loc=historical_file_metric.loc,
+            loc=file_metric.loc,
+            historical_totalCc=historical_file_metric.totalCc,
+            totalCc=file_metric.totalCc,
+            historical_avgCcPerFunction=historical_file_metric.avgCcPerFunction,
+            avgCcPerFunction=file_metric.avgCcPerFunction,
+            historical_maintainabilityIndex=historical_file_metric.maintainabilityIndex,
+            maintainabilityIndex=file_metric.maintainabilityIndex,
+            historical_avgLocPerFunction=historical_file_metric.avgLocPerFunction,
+            avgLocPerFunction=file_metric.avgLocPerFunction,
+        )
+
+    def create_class_trend_metric(
+        self, class_metric: ClassNode, historical_class_metric: ClassNode
+    ) -> ClassTrendMetric:
+        return ClassTrendMetric(
+            historical_lineno=historical_class_metric.lineno,
+            lineno=class_metric.lineno,
+            historical_real_complexity=historical_class_metric.real_complexity,
+            real_complexity=class_metric.real_complexity,
+        )
+
+    def create_function_trend_metric(
+        self, function_metric: FunctionNode, historical_function_metric: FunctionNode
+    ) -> FunctionTrendMetric:
+        return FunctionTrendMetric(
+            historical_loc=historical_function_metric.get_loc(),
+            loc=function_metric.get_loc(),
+            historical_complexity=historical_function_metric.complexity,
+            complexity=function_metric.complexity,
+            historical_maintainability_index=historical_function_metric.maintainability_index,
+            maintainability_index=function_metric.maintainability_index,
+        )
+
+    def add_historical_file_trends(
+        self,
+        file_metrics: list[FileMetrics],
+        historical_file_metrics: list[FileMetrics],
+    ):
+        indexed_file_metrics = {m.full_name: m for m in file_metrics}
+        indexed_historical_file_metrics = {
+            m.full_name: m for m in historical_file_metrics
+        }
+
+        for full_name, file_metric in indexed_file_metrics.items():
+            historical_file_metric = indexed_historical_file_metrics.get(full_name)
+            if not historical_file_metric:
+                continue
+            file_metric.trend = self.create_file_trend_metric(
+                file_metric, historical_file_metric
+            )
+
+            indexed_class_nodes = {
+                n.full_name: n for n in historical_file_metric.class_nodes
+            }
+            for class_node in file_metric.class_nodes:
+                historical_class_node = indexed_class_nodes.get(class_node.full_name)
+                if not historical_class_node:
+                    continue
+                class_node.trend = self.create_class_trend_metric(
+                    class_node, historical_class_node
+                )
+
+                indexed_function_nodes = {
+                    n.full_name: n for n in historical_class_node.functions
+                }
+                for function_node in class_node.functions:
+                    historical_function_node = indexed_function_nodes.get(
+                        function_node.full_name
+                    )
+                    if not historical_function_node:
+                        continue
+                    function_node.trend = self.create_function_trend_metric(
+                        function_node, historical_function_node
+                    )
+
+            indexed_function_nodes = {
+                n.full_name: n for n in historical_file_metric.function_nodes
+            }
+            for function_node in file_metric.function_nodes:
+                historical_function_node = indexed_function_nodes.get(
+                    function_node.full_name
+                )
+                if not historical_function_node:
+                    continue
+                function_node.trend = self.create_function_trend_metric(
+                    function_node, historical_function_node
+                )
+
+    def create_aggregated_trend_metric(
+        self,
+        aggregated_metric: AggregatedMetrics,
+        historical_aggregated_metric: AggregatedMetrics,
+    ) -> AggregatedTrendMetric:
+        return AggregatedTrendMetric(
+            historical_loc=historical_aggregated_metric.loc,
+            loc=aggregated_metric.loc,
+            historical_avgCcPerFunction=historical_aggregated_metric.avgCcPerFunction,
+            avgCcPerFunction=aggregated_metric.avgCcPerFunction,
+            historical_maintainabilityIndex=historical_aggregated_metric.maintainabilityIndex,
+            maintainabilityIndex=aggregated_metric.maintainabilityIndex,
+            historical_avgLocPerFunction=historical_aggregated_metric.avgLocPerFunction,
+            avgLocPerFunction=aggregated_metric.avgLocPerFunction,
+            historical_num_files=historical_aggregated_metric.num_files,
+            num_files=aggregated_metric.num_files,
+            historical_segmented_loc=historical_aggregated_metric.segmentation_data[
+                "loc"
+            ],
+            segmented_loc=aggregated_metric.segmentation_data["loc"],
+            historical_segmented_complexity=historical_aggregated_metric.segmentation_data[
+                "complexity"
+            ],
+            segmented_complexity=aggregated_metric.segmentation_data["complexity"],
+            historical_segmented_maintainability=historical_aggregated_metric.segmentation_data[
+                "maintainability"
+            ],
+            segmented_maintainability=aggregated_metric.segmentation_data[
+                "maintainability"
+            ],
+            historical_segmented_method_size=historical_aggregated_metric.segmentation_data[
+                "methodSize"
+            ],
+            segmented_method_size=aggregated_metric.segmentation_data["methodSize"],
+        )
+
+    def add_historical_project_trends(
+        self,
+        project_metrics: ProjectMetrics,
+        historical_project_metrics: ProjectMetrics,
+    ):
+        project_metrics.total_code_metrics.trend = self.create_aggregated_trend_metric(
+            project_metrics.total_code_metrics,
+            historical_project_metrics.total_code_metrics,
+        )

{metripy-0.2.8.dist-info → metripy-0.3.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: metripy
-Version: 0.2.8
+Version: 0.3.0
 Summary: A Python tool to generate multi project, multi language code metric reports
 Author-email: Yannick Zimmermann <yannick.zimmermann@proton.me>
 License: MIT
-Project-URL: Homepage, https://github.com/zimmer-yan/metripy
+Project-URL: Homepage, https://zimmer-yan.github.io/metripy/
 Project-URL: Repository, https://github.com/zimmer-yan/metripy
-Project-URL: Documentation, https://github.com/zimmer-yan/metripy#readme
+Project-URL: Documentation, https://zimmer-yan.github.io/metripy/
 Project-URL: Bug Tracker, https://github.com/zimmer-yan/metripy/issues
 Keywords: code metrics,multi-language,code analysis,git metrics,code visualization,software quality,static analysis,repository insights,developer productivity,codebase health,technical debt,language-agnostic
 Classifier: Development Status :: 3 - Alpha