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

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