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

metripy/Import/Json/JsonImporter.py

@@ -0,0 +1,17 @@
+import json
+
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class JsonImporter:
+    def __init__(self, output: CliOutput):
+        self.output = output
+
+    def import_data(self, path: str) -> ProjectMetrics:
+        self.output.writeln(f"<info>Importing data from {path}...</info>")
+        with open(path, "r") as file:
+            data = json.load(file)
+            project_metrics = ProjectMetrics.from_dict(data)
+        self.output.writeln("<success>Data imported successfuly</success>")
+        return project_metrics

metripy/LangAnalyzer/AbstractLangAnalyzer.py

@@ -40,13 +40,13 @@ class AbstractLangAnalyzer(ABC):
             full_name = module.full_name
 
             if len(module.functions) > 0:
-                avgCcPerFunction = sum(
-                    function.complexity for function in module.functions
-                ) / len(module.functions)
+                totalCc = sum(function.complexity for function in module.functions)
+                avgCcPerFunction = totalCc / len(module.functions)
                 avgLocPerFunction = (
                     module.lloc - module.comments - len(module.functions)
                 ) / len(module.functions)
             else:
+                totalCc = 0
                 avgCcPerFunction = 0
                 avgLocPerFunction = 0
             maintainabilityIndex = module.maintainability_index
@@ -54,6 +54,7 @@ class AbstractLangAnalyzer(ABC):
             file_metric = FileMetrics(
                 full_name=full_name,
                 loc=module.loc,
+                totalCc=totalCc,
                 avgCcPerFunction=avgCcPerFunction,
                 maintainabilityIndex=maintainabilityIndex,
                 avgLocPerFunction=avgLocPerFunction,

metripy/LangAnalyzer/Php/PhpAnalyzer.py

@@ -131,7 +131,7 @@ class PhpAnalyzer(AbstractLangAnalyzer):
 
         code_lines = code.split("\n")
         for func_name, function_node in functions.items():
-            lines = code_lines[function_node.lineno:function_node.line_end]
+            lines = code_lines[function_node.lineno : function_node.line_end]
             function_metrics = self.halstead_analyzer.calculate_halstead_metrics(
                 "\n".join(lines)
             )
@@ -147,6 +147,7 @@ class PhpAnalyzer(AbstractLangAnalyzer):
             function_node.calculated_length = function_metrics["calculated_length"]
             function_node.bugs = function_metrics["bugs"]
             function_node.time = function_metrics["time"]
+            function_node.calc_mi()
 
         maintainability_index = self._calculate_maintainability_index(
             functions.values(), module_node

metripy/LangAnalyzer/Python/PythonAnalyzer.py

@@ -5,6 +5,7 @@ from radon.visitors import Class, Function
 
 from metripy.Component.Output.ProgressBar import ProgressBar
 from metripy.LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from metripy.LangAnalyzer.Python.PythonHalSteadAnalyzer import PythonHalSteadAnalyzer
 from metripy.Metric.Code.FileMetrics import FileMetrics
 from metripy.Tree.ClassNode import ClassNode
 from metripy.Tree.FunctionNode import FunctionNode
@@ -15,6 +16,7 @@ class PythonAnalyzer(AbstractLangAnalyzer):
 
     def __init__(self):
         super().__init__()
+        self.fallback_halstead_analyzer = PythonHalSteadAnalyzer()
 
     def get_lang_name(self) -> str:
         return "Python"
@@ -62,6 +64,7 @@ class PythonAnalyzer(AbstractLangAnalyzer):
                 function_node = FunctionNode(
                     full_name, item.name, item.lineno, item.col_offset, item.complexity
                 )
+                function_node.line_end = item.endline
                 if item.is_method:
                     class_node = classes.get(full_class_name)
                     if class_node is not None:
@@ -74,11 +77,6 @@ class PythonAnalyzer(AbstractLangAnalyzer):
             else:
                 raise ValueError(f"Unknown item type: {type(item)}")
 
-        # print("--------------------------------")
-        # print(json.dumps([c.__dict__() for c in classes.values()], indent=4))
-        # print("--------------------------------")
-        # print(json.dumps([f.__dict__() for f in functions.values()], indent=4))
-        # exit()
         module = analyze(code)
         full_name = self.full_name(filename)
         module_node = ModuleNode(
@@ -93,12 +91,9 @@ class PythonAnalyzer(AbstractLangAnalyzer):
         )
         module_node.classes.extend(classes.values())
         module_node.functions.extend(functions.values())
-        # print(module)
-        # print(json.dumps([m.to_dict() for m in modules.values()], indent=4))
-        # exit()
+
         h = h_visit(code)
         assert isinstance(h, Halstead)
-        # print(h.total)
         function_name: str
         report: HalsteadReport
         for function_name, report in h.functions:
@@ -117,9 +112,36 @@ class PythonAnalyzer(AbstractLangAnalyzer):
                 function_node.effort = report.effort
                 function_node.bugs = report.bugs
                 function_node.time = report.time
+                function_node.calc_mi()
             else:
                 raise ValueError(f"Function node not found for function {full_name}")
 
+        code_lines = code.split("\n")
+        for func_name, function_node in functions.items():
+            if function_node.maintainability_index != 0:
+                continue
+            # if MI is 0, we want to take another look, radon does not like boring functions
+
+            lines = code_lines[function_node.lineno : function_node.line_end]
+            function_metrics = (
+                self.fallback_halstead_analyzer.calculate_halstead_metrics(
+                    "\n".join(lines)
+                )
+            )
+            function_node.h1 = function_metrics["n1"]
+            function_node.h2 = function_metrics["n2"]
+            function_node.N1 = function_metrics["N1"]
+            function_node.N2 = function_metrics["N2"]
+            function_node.vocabulary = function_metrics["vocabulary"]
+            function_node.length = function_metrics["length"]
+            function_node.volume = function_metrics["volume"]
+            function_node.difficulty = function_metrics["difficulty"]
+            function_node.effort = function_metrics["effort"]
+            function_node.calculated_length = function_metrics["calculated_length"]
+            function_node.bugs = function_metrics["bugs"]
+            function_node.time = function_metrics["time"]
+            function_node.calc_mi()
+
         maintainability_index = mi_visit(code, True)
         module_node.maintainability_index = maintainability_index
 

metripy/LangAnalyzer/Python/PythonHalSteadAnalyzer.py

@@ -0,0 +1,55 @@
+from metripy.LangAnalyzer.Generic.HalSteadAnalyzer import HalSteadAnalyzer
+
+
+class PythonHalSteadAnalyzer:
+    def __init__(self):
+        self.operators = [
+            "+",
+            "-",
+            "*",
+            "/",
+            "//",
+            "%",
+            "**",
+            "==",
+            "!=",
+            ">",
+            "<",
+            ">=",
+            "<=",
+            "=",
+            "+=",
+            "-=",
+            "*=",
+            "/=",
+            "%=",
+            "//=",
+            "**=",
+            "and",
+            "or",
+            "not",
+            "&",
+            "|",
+            "^",
+            "~",
+            "<<",
+            ">>",
+            "in",
+            "not in",
+            "is",
+            "is not",
+            ":",
+            ",",
+            ".",
+            "(",
+            ")",
+            "[",
+            "]",
+            "{",
+            "}",
+        ]
+
+        self.analyzer = HalSteadAnalyzer(self.operators)
+
+    def calculate_halstead_metrics(self, code: str):
+        return self.analyzer.calculate_halstead_metrics(code)

metripy/LangAnalyzer/Typescript/TypescriptAnalyzer.py

@@ -4,14 +4,16 @@ import lizard
 
 from metripy.Component.Output.ProgressBar import ProgressBar
 from metripy.LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
-from metripy.LangAnalyzer.Typescript.TypescriptAstParser import \
-    TypescriptAstParser
-from metripy.LangAnalyzer.Typescript.TypescriptBasicComplexityAnalyzer import \
-    TypescriptBasicComplexityAnalzyer
-from metripy.LangAnalyzer.Typescript.TypescriptBasicLocAnalyzer import \
-    TypescriptBasicLocAnalyzer
-from metripy.LangAnalyzer.Typescript.TypescriptHalSteadAnalyzer import \
-    TypeScriptHalSteadAnalyzer
+from metripy.LangAnalyzer.Typescript.TypescriptAstParser import TypescriptAstParser
+from metripy.LangAnalyzer.Typescript.TypescriptBasicComplexityAnalyzer import (
+    TypescriptBasicComplexityAnalzyer,
+)
+from metripy.LangAnalyzer.Typescript.TypescriptBasicLocAnalyzer import (
+    TypescriptBasicLocAnalyzer,
+)
+from metripy.LangAnalyzer.Typescript.TypescriptHalSteadAnalyzer import (
+    TypeScriptHalSteadAnalyzer,
+)
 from metripy.Tree.ClassNode import ClassNode
 from metripy.Tree.FunctionNode import FunctionNode
 from metripy.Tree.ModuleNode import ModuleNode
@@ -146,7 +148,7 @@ class TypescriptAnalyzer(AbstractLangAnalyzer):
 
         code_lines = code.split("\n")
         for func_name, function_node in functions.items():
-            lines = code_lines[function_node.lineno:function_node.line_end]
+            lines = code_lines[function_node.lineno : function_node.line_end]
             function_metrics = self.halstead_analyzer.calculate_halstead_metrics(
                 "\n".join(lines)
             )
@@ -162,6 +164,7 @@ class TypescriptAnalyzer(AbstractLangAnalyzer):
             function_node.calculated_length = function_metrics["calculated_length"]
             function_node.bugs = function_metrics["bugs"]
             function_node.time = function_metrics["time"]
+            function_node.calc_mi()
 
         maintainability_index = self._calculate_maintainability_index(
             functions.values(), module_node

metripy/LangAnalyzer/Typescript/TypescriptAstParser.py

@@ -8,7 +8,7 @@ class TypescriptAstParser:
         self.parser = get_parser("typescript")
 
     def _get_node_text(self, code: str, node) -> str:
-        return code[node.start_byte:node.end_byte].decode("utf-8")
+        return code[node.start_byte : node.end_byte].decode("utf-8")
 
     def extract_structure(self, code: str) -> dict:
         tree = self.parser.parse(bytes(code, "utf8"))

metripy/Metric/Code/AggregatedMetrics.py

@@ -1,4 +1,5 @@
 from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+from metripy.Metric.Trend.AggregatedTrendMetric import AggregatedTrendMetric
 
 
 class AggregatedMetrics:
@@ -29,13 +30,19 @@ class AggregatedMetrics:
             "methodSize": segmented_method_size,
         }
 
+        self.trend: AggregatedTrendMetric | None = None
+
     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,
+            "trend": self.trend.to_dict() if self.trend else None,
+            "trend_segmentation": (
+                self.trend.to_dict_segmentation() if self.trend else None
+            ),
         }
 
     def to_dict_segmentation(self) -> dict:

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,44 @@
+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"
+        else:
+            return "critical"

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,3 +1,5 @@
+from typing import Self
+
 from metripy.Dependency.Dependency import Dependency
 from metripy.Metric.Code.AggregatedMetrics import AggregatedMetrics
 from metripy.Metric.Code.FileMetrics import FileMetrics
@@ -53,3 +55,30 @@ class ProjectMetrics:
 
     def _avg(self, items: list[float | int]) -> float:
         return sum(items) / len(items)
+
+    def to_dict(self) -> dict:
+        data = {
+            "file_metrics": [m.to_dict() for m in self.file_metrics],
+            "aggregated": self.total_code_metrics.to_dict(),
+            "aggregated_segmented": self.total_code_metrics.to_dict_segmentation(),
+        }
+        if self.git_metrics:
+            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
+            )
+        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,
+        )