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

metripy/Metric/Code/FileMetrics.py

@@ -1,3 +1,7 @@
+from typing import Self
+
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.Trend.FileTrendMetric import FileTrendMetric
 from metripy.Tree.ClassNode import ClassNode
 from metripy.Tree.FunctionNode import FunctionNode
 
@@ -7,6 +11,7 @@ class FileMetrics:
         self,
         full_name: str,
         loc: int,
+        totalCc: int,
         avgCcPerFunction: float,
         maintainabilityIndex: float,
         avgLocPerFunction: float,
@@ -15,19 +20,45 @@ class FileMetrics:
     ):
         self.full_name = full_name
         self.loc = loc
+        self.totalCc = totalCc
         self.avgCcPerFunction = avgCcPerFunction
         self.maintainabilityIndex = maintainabilityIndex
         self.avgLocPerFunction = avgLocPerFunction
         self.class_nodes = class_nodes
         self.function_nodes = function_nodes
+        self.trend: FileTrendMetric | None = None
 
     def to_dict(self) -> dict:
         return {
             "full_name": self.full_name,
             "loc": self.loc,
+            "loc_segment": Segmentor.get_loc_segment(self.loc),
+            "totalCc": self.totalCc,
+            "complexity_segment": Segmentor.get_complexity_segment(
+                self.avgCcPerFunction
+            ),
             "avgCcPerFunction": self.avgCcPerFunction,
-            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "maintainabilityIndex": round(self.maintainabilityIndex, 2),
+            "maintainability_segment": Segmentor.get_maintainability_segment(
+                self.maintainabilityIndex
+            ),
             "avgLocPerFunction": self.avgLocPerFunction,
+            "method_size_segment": Segmentor.get_method_size_segment(
+                self.avgLocPerFunction
+            ),
             "class_nodes": [node.to_dict() for node in self.class_nodes],
             "function_nodes": [node.to_dict() for node in self.function_nodes],
         }
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        return FileMetrics(
+            full_name=data["full_name"],
+            loc=data["loc"],
+            totalCc=data["totalCc"],
+            avgCcPerFunction=data["avgCcPerFunction"],
+            maintainabilityIndex=data["maintainabilityIndex"],
+            avgLocPerFunction=data["avgLocPerFunction"],
+            class_nodes=[ClassNode.from_dict(d) for d in data["class_nodes"]],
+            function_nodes=[FunctionNode.from_dict(d) for d in data["function_nodes"]],
+        )

metripy/Metric/Code/ModuleMetrics.py

@@ -22,11 +22,11 @@ class ModuleMetrics:
 
     def to_dict(self) -> dict:
         return {
-            "loc": str(self.loc),
-            "avgCcPerFunction": f"{self.avgCcPerFunction:.2f}",
-            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
-            "avgLocPerFunction": f"{self.avgLocPerFunction:.2f}",
-            "num_files": str(self.num_files),
+            "loc": self.loc,
+            "avgCcPerFunction": round(self.avgCcPerFunction, 2),
+            "maintainabilityIndex": round(self.maintainabilityIndex, 2),
+            "avgLocPerFunction": round(self.avgLocPerFunction, 2),
+            "num_files": self.num_files,
             "class_nodes": [node.to_dict() for node in self.class_nodes],
             "function_nodes": [node.to_dict() for node in self.function_nodes],
         }

metripy/Metric/Code/SegmentedMetrics.py

@@ -1,5 +1,7 @@
 from typing import Self
 
+from metripy.Metric.Code.Segmentor import Segmentor
+
 
 class SegmentedMetrics:
     def __init__(self):
@@ -16,50 +18,84 @@ class SegmentedMetrics:
             "critical": self.critical,
         }
 
+    def to_dict_with_percent(self) -> dict:
+        return {
+            "good": self.good,
+            "good_percent": round(
+                self.good / (self.good + self.ok + self.warning + self.critical) * 100,
+                2,
+            ),
+            "ok": self.ok,
+            "ok_percent": round(
+                self.ok / (self.good + self.ok + self.warning + self.critical) * 100, 2
+            ),
+            "warning": self.warning,
+            "warning_percent": round(
+                self.warning
+                / (self.good + self.ok + self.warning + self.critical)
+                * 100,
+                2,
+            ),
+            "critical": self.critical,
+            "critical_percent": round(
+                self.critical
+                / (self.good + self.ok + self.warning + self.critical)
+                * 100,
+                2,
+            ),
+        }
+
+    def _set_values(self, values: dict[str, int]) -> Self:
+        self.good = values["good"]
+        self.ok = values["ok"]
+        self.warning = values["warning"]
+        self.critical = values["critical"]
+        return self
+
     def set_loc(self, values: list[int]) -> Self:
+        d = {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
         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
+            d[Segmentor.get_loc_segment(value)] += 1
+
+        return self._set_values(d)
 
     def set_complexity(self, values: list[int]) -> Self:
+        d = {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
         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
+            d[Segmentor.get_complexity_segment(value)] += 1
+
+        return self._set_values(d)
 
     def set_maintainability(self, values: list[int]) -> Self:
+        d = {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
         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
+            d[Segmentor.get_maintainability_segment(value)] += 1
+
+        return self._set_values(d)
 
     def set_method_size(self, values: list[int]) -> Self:
+        d = {
+            "good": self.good,
+            "ok": self.ok,
+            "warning": self.warning,
+            "critical": self.critical,
+        }
         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
+            d[Segmentor.get_method_size_segment(value)] += 1
+
+        return self._set_values(d)

metripy/Metric/Code/Segmentor.py

@@ -0,0 +1,42 @@
+class Segmentor:
+    @staticmethod
+    def get_loc_segment(loc: int) -> str:
+        if loc <= 200:
+            return "good"
+        elif loc <= 500:
+            return "ok"
+        elif loc <= 1000:
+            return "warning"
+        else:
+            return "critical"
+
+    @staticmethod
+    def get_complexity_segment(complexity: float) -> str:
+        if complexity <= 5:
+            return "good"
+        elif complexity <= 10:
+            return "ok"
+        elif complexity <= 20:
+            return "warning"
+        else:
+            return "critical"
+
+    @staticmethod
+    def get_maintainability_segment(maintainability: float) -> str:
+        if maintainability > 80:
+            return "good"
+        elif maintainability > 60:
+            return "ok"
+        elif maintainability > 40:
+            return "warning"
+        else:
+            return "critical"
+
+    @staticmethod
+    def get_method_size_segment(method_size: float) -> str:
+        if method_size <= 15:
+            return "good"
+        elif method_size <= 30:
+            return "ok"
+        elif method_size <= 50:
+            return "warning"

metripy/Metric/FileTree/FileTreeParser.py

@@ -36,7 +36,3 @@ class FileTreeParser:
 
         for child in node.children:
             FileTreeParser._shorten_tree(child)
-
-        # print(json.dumps(root.to_dict(), indent=4))
-        # exit()
-        # return root

metripy/Metric/Git/GitMetrics.py

@@ -136,7 +136,7 @@ class GitMetrics:
     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}",
+            "avg_commit_size": round(self.get_avg_commit_size(), 2),
             "commit_stats_per_month": self.get_commit_stats_per_month(),
             "churn_per_month": self.get_churn_per_month(),
             "total_commits": self.total_commits,

metripy/Metric/ProjectMetrics.py

@@ -1,9 +1,10 @@
+from typing import Self
+
 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
-from metripy.Dependency.Dependency import Dependency
 
 
 class ProjectMetrics:
@@ -65,5 +66,19 @@ class ProjectMetrics:
             data["git_metrics"] = self.git_metrics.to_dict()
         if self.dependencies:
             data["dependencies"] = [d.to_dict() for d in self.dependencies]
-            data["license_distribution"] = Dependency.get_lisence_distribution(self.dependencies)
+            data["license_distribution"] = Dependency.get_lisence_distribution(
+                self.dependencies
+            )
         return data
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        # TODO: not needed yet
+        # git_metrics = GitMetrics.from_dict(data["git_metrics"]) if "git_metrics" in data.keys() else None
+        # dependencies = [Dependency.from_dict(d) for d in data["dependencies"]] if "dependencies" in data.keys() else None
+
+        return ProjectMetrics(
+            file_metrics=[FileMetrics.from_dict(m) for m in data["file_metrics"]],
+            git_metrics=None,
+            dependencies=None,
+        )

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