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

metripy/Application/Analyzer.py

@@ -7,14 +7,15 @@ from metripy.Dependency.Dependency import Dependency
 from metripy.Dependency.Npm.Npm import Npm
 from metripy.Dependency.Pip.Pip import Pip
 from metripy.Git.GitAnalyzer import GitAnalyzer
+from metripy.Import.Json.JsonImporter import JsonImporter
 from metripy.LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
 from metripy.LangAnalyzer.Php.PhpAnalyzer import PhpAnalyzer
 from metripy.LangAnalyzer.Python.PythonAnalyzer import PythonAnalyzer
-from metripy.LangAnalyzer.Typescript.TypescriptAnalyzer import \
-    TypescriptAnalyzer
+from metripy.LangAnalyzer.Typescript.TypescriptAnalyzer import TypescriptAnalyzer
 from metripy.Metric.Code.FileMetrics import FileMetrics
 from metripy.Metric.Git.GitMetrics import GitMetrics
 from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Trend.TrendAnalyzer import TrendAnalyzer
 
 
 class Analyzer:
@@ -85,6 +86,18 @@ class Analyzer:
 
         return dependencies
 
+    def add_trends(self, project_metrics: ProjectMetrics):
+        self.output.writeln("<info>Analyzing trends...</info>")
+        importer = JsonImporter(self.output)
+        historical_project_metrics = importer.import_data(self.config.history_path)
+        TrendAnalyzer().add_historical_file_trends(
+            project_metrics.file_metrics, historical_project_metrics.file_metrics
+        )
+        TrendAnalyzer().add_historical_project_trends(
+            project_metrics, historical_project_metrics
+        )
+        self.output.writeln("<success>Trends analyzed</success>")
+
     def run(self, files: list[str]) -> ProjectMetrics:
         git_stats = None
         if self.config.git:
@@ -103,4 +116,11 @@ class Analyzer:
         elif self.config.npm:
             packages = self.analyze_npm()
 
-        return ProjectMetrics(file_metrics, git_stats, packages)
+        if not self.config.history_path:
+            return ProjectMetrics(file_metrics, git_stats, packages)
+
+        # analyze trends
+        project_metrics = ProjectMetrics(file_metrics, git_stats, packages)
+        self.add_trends(project_metrics)
+
+        return project_metrics

metripy/Application/Application.py

@@ -8,15 +8,30 @@ from metripy.Component.Output.CliOutput import CliOutput
 from metripy.Report.ReporterFactory import ReporterFactory
 from metripy.Report.ReporterInterface import ReporterInterface
 
+from metripy.Application.Info import Info
+
 
 class Application:
     def run(self, argv) -> None:
         output = CliOutput()
 
         # issues and debug
-        debugger = Debugger(output).enable()
+        debugger = Debugger(output)
 
         config = Parser().parse(argv)
+        if config.debug:
+            debugger.enable()
+
+        if config.version:
+            output.writeln(Info().get_version_info())
+            return
+
+        if config.help:
+            output.writeln(Info().get_help())
+            return
+
+        if config.quiet:
+            output.set_quiet(True)
 
         finder = Finder()
         files = finder.fetch(config.project_configs)

metripy/Application/Config/Config.py

@@ -4,6 +4,10 @@ from metripy.Application.Config.ProjectConfig import ProjectConfig
 class Config:
     def __init__(self):
         self.project_configs: list[ProjectConfig] = []
+        self.quiet: bool = False
+        self.version: bool = False
+        self.help: bool = False
+        self.debug: bool = False
 
     def to_dict(self) -> dict:
         return {
@@ -11,3 +15,32 @@ class Config:
                 project_config.to_dict() for project_config in self.project_configs
             ],
         }
+
+    def set(self, param: str, value: any) -> None:
+        print(f"Setting {param} to {value}")
+        if param == "quiet":
+            self.quiet = value
+        elif param == "version":
+            self.version = value
+        elif param == "help":
+            self.help = value
+        elif param == "debug":
+            self.debug = value
+        elif param.startswith("configs."):
+            self._set_project_value(param[len("configs."):], value)
+        else:
+            # ignore unknown parameters
+            return
+
+    def _set_project_value(self, param: str, value: any) -> None:
+        keys = param.split(".")
+        project_name = keys[0]
+        project_config = next((pc for pc in self.project_configs if pc.name == project_name), None)
+        if not project_config:
+            project_config = ProjectConfig(project_name)
+            self.project_configs.append(project_config)
+        if len(keys) > 1:
+            project_config.set(keys[1:], value)
+        else:
+            # weird but okay
+            return

metripy/Application/Config/File/ConfigFileReaderFactory.py

@@ -1,10 +1,10 @@
 import os
 import pathlib
 
-from metripy.Application.Config.File.ConfigFileReaderInterface import \
-    ConfigFileReaderInterface
-from metripy.Application.Config.File.JsonConfigFileReader import \
-    JsonConfigFileReader
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
+from metripy.Application.Config.File.JsonConfigFileReader import JsonConfigFileReader
 
 
 class ConfigFileReaderFactory:

metripy/Application/Config/File/JsonConfigFileReader.py

@@ -2,8 +2,9 @@ import json
 import os
 
 from metripy.Application.Config.Config import Config
-from metripy.Application.Config.File.ConfigFileReaderInterface import \
-    ConfigFileReaderInterface
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
 from metripy.Application.Config.GitConfig import GitConfig
 from metripy.Application.Config.ProjectConfig import ProjectConfig
 from metripy.Application.Config.ReportConfig import ReportConfig
@@ -79,4 +80,8 @@ class JsonConfigFileReader(ConfigFileReaderInterface):
         if npm := json_data.get("npm"):
             project_config.npm = npm
 
+        # trends
+        if history_path := json_data.get("trends"):
+            project_config.history_path = self.resolve_path(history_path)
+
         return project_config

metripy/Application/Config/Parser.py

@@ -1,21 +1,24 @@
 import re
 
 from metripy.Application.Config.Config import Config
-from metripy.Application.Config.File.ConfigFileReaderFactory import \
-    ConfigFileReaderFactory
+from metripy.Application.Config.File.ConfigFileReaderFactory import (
+    ConfigFileReaderFactory,
+)
 
 
 class Parser:
     def parse(self, argv: list[str]) -> Config:
         config = Config()
+        print(argv)
 
-        if argv[0] == "metripy.py" or argv[0] == "metripy":
-            # TODO, fix when path ends with metripy.py
-            pass
-        argv.pop(0)
+        if argv[0].endswith("metripy.py") or argv[0].endswith("metripy"):
+            argv.pop(0)
 
         # check for a config file
-        for key, arg in enumerate(argv):
+        key = 0
+        while key < len(argv):
+            arg = argv[key]
+            print(f"Key: {key} Arg: '{arg}'")
             if matches := re.search(r"^--config=(.+)$", arg):
                 fileReader = ConfigFileReaderFactory.createFromFileName(
                     matches.group(1)
@@ -23,9 +26,21 @@ class Parser:
                 fileReader.read(config)
                 argv.pop(key)
 
-        # TODO: add the following
-        # arguments with options
-        # arguments without options
-        # last argument
+            # arguments with options
+            elif matches := re.search(r"^--([\w]+(?:\.[\w]+)*)=(.*)$", arg):
+                param = matches.group(1)
+                value = matches.group(2)
+                config.set(param, value)
+                argv.pop(key)
+
+            # arguments without options
+            elif matches := re.search(r"^--([\w]+(?:\.[\w]+)*)$", arg):
+                param = matches.group(1)
+                config.set(param, True)
+                argv.pop(key)
+            else:
+                key += 1
+
+        # TODO handle remaining arguments
 
         return config

metripy/Application/Config/ProjectConfig.py

@@ -14,6 +14,7 @@ class ProjectConfig:
         self.pip: bool = False
         self.npm: bool = False
         self.reports: list[ReportConfig] = []
+        self.history_path: str | None = None
 
     def to_dict(self) -> dict:
         return {
@@ -22,6 +23,68 @@ class ProjectConfig:
             "includes": self.includes,
             "excludes": self.excludes,
             "extensions": self.extensions,
+            "composer": self.composer,
+            "pip": self.pip,
+            "npm": self.npm,
             "git": self.git.to_dict() if self.git else None,
             "reports": [report.to_dict() for report in self.reports],
+            "history_path": self.history_path,
         }
+
+    @staticmethod
+    def str_to_bool(value):
+        if isinstance(value, bool):
+            return value
+        return str(value).lower() in ("true", "1", "yes")
+
+    def set(self, keys: list[str], value: any) -> None:
+        if len(keys) == 0:
+            return
+        primary_key = keys[0]
+        print(f"Setting primary {primary_key} to {value}")
+        # single value
+        if primary_key == "base_path":
+            self.base_path = value
+        elif primary_key == "pip":
+            self.pip = self.str_to_bool(value)
+        elif primary_key == "npm":
+            self.npm = self.str_to_bool(value)
+        elif primary_key == "composer":
+            self.composer = self.str_to_bool(value)
+        elif primary_key == "trends":
+            self.history_path = value
+        elif primary_key == "git":
+            self.git = GitConfig()
+            self.git.repo = self.base_path
+            self.git.branch = value
+
+        # list values
+        elif primary_key == "includes":
+            if value == "":
+                self.includes = []
+            else:
+                self.includes.append(value)
+        elif primary_key == "excludes":
+            if value == "":
+                self.excludes = []
+            else:
+                self.excludes.append(value)
+        elif primary_key == "extensions":
+            if value == "":
+                self.extensions = []
+            else:
+                self.extensions.append(value)
+
+        # dict values
+        elif primary_key == "reports":
+            if len(keys) == 1:
+                return
+            report_type = keys[1]
+            report_path = value
+            if value != "":
+                self.reports.append(ReportConfig(report_type, report_path))
+            else:
+                report_config = next((rc for rc in self.reports if rc.type == report_type), None)
+                if not report_config:
+                    return
+                self.reports.remove(report_config)

metripy/Application/Info.py

@@ -0,0 +1,29 @@
+import toml
+
+class Info:
+    def __init__(self):
+        data = self._get_data()
+        self.version = data["project"]["version"]
+        self.url = data["project"]["urls"]["Homepage"]
+
+    def _get_data(self) -> dict:
+        with open("pyproject.toml", "r") as file:
+            data = toml.load(file)
+        return data
+
+    def get_version_info(self) -> str:
+        return f"""
+Metripy {self.version}
+{self.url}
+"""
+
+    def get_help(self) -> str:
+        return self.get_version_info() + f"""
+Usage: metripy [options]
+Options:
+ --config=<file>    Use a custom config file
+ --version            Show the version and exit
+ --help               Show this help message and exit
+ --debug              Enable debug mode
+ --quiet              Disable output
+"""

metripy/Dependency/Dependency.py

@@ -1,7 +1,8 @@
 from typing import Self
 
+
 class Dependency:
-    def __init__(self, name: str, version: str|None):
+    def __init__(self, name: str, version: str | None):
         self.name = name
         self.version = version
         self.latest: str = ""

metripy/Dependency/Pip/Pip.py

@@ -1,5 +1,4 @@
 import os
-import re
 
 import toml
 
@@ -39,7 +38,7 @@ class Pip:
                 return self._parse_dependencies(deps)
 
         return []
-    
+
     def _parse_dependencies(self, lines: list[str]) -> list[Dependency]:
         dependencies = []
         for dep in lines:

metripy/Dependency/Pip/PyPi.py

@@ -16,6 +16,7 @@ class PyPi:
             print(f"Package '{dependency.name}' has no info section")
             return dependency
 
+        dependency.type = "pip"
         dependency.description = info.get("summary")
         dependency.repository = info.get("project_url") or info.get("home_page")
         if info.get("license"):

metripy/Git/GitAnalyzer.py

@@ -9,8 +9,6 @@ from metripy.Metric.Git.GitMetrics import GitMetrics
 
 class GitAnalyzer:
     def __init__(self, git_config: GitConfig):
-        print(git_config.repo)
-        print(git_config.branch)
         self.repo = Repo(git_config.repo)
         self.branch_name = git_config.branch
 
@@ -22,7 +20,6 @@ class GitAnalyzer:
         first_of_month_last_year = datetime(now.year - 1, now.month, 1)
         # first_of_month_last_year = datetime(now.year, now.month, 1)
         after_date = first_of_month_last_year.strftime("%Y-%m-%d")
-        print(f"analyzing from {after_date}")
 
         return self.get_metrics(after_date)
 

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: