metripy 0.2.7__py3-none-any.whl → 0.3.6__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

@@ -2,6 +2,7 @@ import json
 
 from metripy.Application.Analyzer import Analyzer
 from metripy.Application.Config.Parser import Parser
+from metripy.Application.Info import Info
 from metripy.Component.Debug.Debugger import Debugger
 from metripy.Component.File.Finder import Finder
 from metripy.Component.Output.CliOutput import CliOutput
@@ -14,9 +15,22 @@ class Application:
         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)
@@ -46,7 +60,7 @@ class Application:
             )
             for report_config in project_config.reports:
                 reporter: ReporterInterface = ReporterFactory.create(
-                    report_config, output
+                    report_config, output, project_config.name
                 )
                 reporter.generate(project_metrics)
             output.writeln(

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,33 @@ class Config:
                 project_config.to_dict() for project_config in self.project_configs
             ],
         }
+
+    def set(self, param: str, value: any) -> None:
+        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,11 @@
 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
+from metripy.Application.Config.File.YamlConfigFileReader import YamlConfigFileReader
 
 
 class ConfigFileReaderFactory:
@@ -17,7 +18,7 @@ class ConfigFileReaderFactory:
         if extension == ".json":
             return JsonConfigFileReader(filename)
         elif extension == ".yaml" or extension == ".yml":
-            raise NotImplementedError("YAML support is not implemented yet")
+            return YamlConfigFileReader(filename)
         elif extension == ".xml":
             raise NotImplementedError("XML support is not implemented yet")
         else:

metripy/Application/Config/File/ConfigFileReaderInterface.py

@@ -1,14 +1,81 @@
+import os
 from abc import ABC, abstractmethod
 
 from metripy.Application.Config.Config import Config
+from metripy.Application.Config.GitConfig import GitConfig
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+from metripy.Application.Config.ReportConfig import ReportConfig
 
 
 class ConfigFileReaderInterface(ABC):
-
-    @abstractmethod
     def __init__(self, filename: str):
-        pass
+        self.filename = filename
 
     @abstractmethod
     def read(self, config: Config) -> None:
         pass
+
+    def resolve_path(self, path: str) -> str:
+        return path
+
+    def parse_data(self, data: dict, config: Config) -> None:
+        # configs
+        if configs := data.get("configs"):
+            for project_name, project_config in configs.items():
+                project_config = self.parse_config_json(project_name, project_config)
+                config.project_configs.append(project_config)
+
+    def parse_config_json(self, project_name: str, data: dict) -> ProjectConfig:
+        project_config = ProjectConfig(project_name)
+
+        # extensions
+        if base_path := data.get("base_path"):
+            project_config.base_path = base_path
+
+        # includes
+        if includes := data.get("includes"):
+            files = []
+            # with config file, includes are relative to the config file
+            for include in includes:
+                include = self.resolve_path(include)
+                files.append(include)
+
+            project_config.includes = files
+
+        # extensions
+        if extensions := data.get("extensions"):
+            project_config.extensions = extensions
+
+        # excludes
+        if excludes := data.get("excludes"):
+            project_config.excludes = excludes
+
+        # reports
+        if reports := data.get("reports"):
+            for report_type, path in reports.items():
+                path = self.resolve_path(path)
+                project_config.reports.append(ReportConfig(report_type, path))
+
+        # git
+        if git := data.get("git"):
+            project_config.git = GitConfig()
+            project_config.git.repo = project_config.base_path
+            project_config.git.branch = git.get("branch", project_config.git.branch)
+
+        # composer
+        if composer := data.get("composer"):
+            project_config.composer = composer
+
+        # pip
+        if pip := data.get("pip"):
+            project_config.pip = pip
+
+        # npm
+        if npm := data.get("npm"):
+            project_config.npm = npm
+
+        # trends
+        if history_path := data.get("trends"):
+            project_config.history_path = self.resolve_path(history_path)
+
+        return project_config

metripy/Application/Config/File/JsonConfigFileReader.py

@@ -1,82 +1,17 @@
 import json
-import os
 
 from metripy.Application.Config.Config import Config
-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
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
 
 
 class JsonConfigFileReader(ConfigFileReaderInterface):
     def __init__(self, filename: str):
-        self.filename = filename
+        super().__init__(filename)
 
     def read(self, config: Config) -> None:
         with open(self.filename, "r") as file:
             json_data = json.load(file)
 
-        self.parse_json(json_data, config)
-
-    def resolve_path(self, path: str) -> str:
-        return os.path.join(os.path.dirname(self.filename), path)
-
-    def parse_json(self, json_data: dict, config: Config) -> None:
-
-        # configs
-        if configs := json_data.get("configs"):
-            for project_name, project_config in configs.items():
-                project_config = self.parse_config_json(project_name, project_config)
-                config.project_configs.append(project_config)
-
-    def parse_config_json(self, project_name: str, json_data: dict) -> ProjectConfig:
-        project_config = ProjectConfig(project_name)
-
-        # extensions
-        if base_path := json_data.get("base_path"):
-            project_config.base_path = base_path
-
-        # includes
-        if includes := json_data.get("includes"):
-            files = []
-            # with config file, includes are relative to the config file
-            for include in includes:
-                include = self.resolve_path(include)
-                files.append(include)
-
-            project_config.includes = files
-
-        # extensions
-        if extensions := json_data.get("extensions"):
-            project_config.extensions = extensions
-
-        # excludes
-        if excludes := json_data.get("excludes"):
-            project_config.excludes = excludes
-
-        # reports
-        if reports := json_data.get("reports"):
-            for report_type, path in reports.items():
-                path = self.resolve_path(path)
-                project_config.reports.append(ReportConfig(report_type, path))
-
-        # git
-        if git := json_data.get("git"):
-            project_config.git = GitConfig()
-            project_config.git.repo = project_config.base_path
-            project_config.git.branch = git.get("branch", project_config.git.branch)
-
-        # composer
-        if composer := json_data.get("composer"):
-            project_config.composer = composer
-
-        # pip
-        if pip := json_data.get("pip"):
-            project_config.pip = pip
-
-        # npm
-        if npm := json_data.get("npm"):
-            project_config.npm = npm
-
-        return project_config
+        self.parse_data(json_data, config)

metripy/Application/Config/File/YamlConfigFileReader.py

@@ -0,0 +1,17 @@
+import yaml
+
+from metripy.Application.Config.Config import Config
+from metripy.Application.Config.File.ConfigFileReaderInterface import (
+    ConfigFileReaderInterface,
+)
+
+
+class YamlConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        super().__init__(filename)
+
+    def read(self, config: Config) -> None:
+        with open(self.filename, "r") as file:
+            yaml_data = yaml.safe_load(file)
+
+        self.parse_data(yaml_data, config)

metripy/Application/Config/Parser.py

@@ -1,21 +1,22 @@
 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()
 
-        if argv[0] == "codemetrics.py" or argv[0] == "codemetrics":
-            # TODO, fix when path ends with codemetrics.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]
             if matches := re.search(r"^--config=(.+)$", arg):
                 fileReader = ConfigFileReaderFactory.createFromFileName(
                     matches.group(1)
@@ -23,9 +24,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,69 @@ 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]
+        # 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,61 @@
+from importlib.metadata import version, metadata
+import toml
+
+
+class Info:
+    def __init__(self):
+        self.version = self._get_version()
+        self.url = self._get_homepage_url()
+
+    def _get_pyproject_data(self) -> dict:
+        with open("pyproject.toml", "r") as file:
+            data = toml.load(file)
+        return data
+
+    def _get_version(self) -> str:
+        """Get version from installed package metadata"""
+        try:
+            return version("metripy")
+        except Exception:
+            # Fallback for development if not installed
+            return self._get_pyproject_data()["project"]["version"]
+    
+    def _get_homepage_url(self) -> str:
+        """Get homepage URL from installed package metadata"""
+        try:
+            meta = metadata("metripy")
+            # Try to get Home-Page from metadata
+            homepage = meta.get("Home-Page")
+            if not homepage:
+                # Try Project-URL field
+                for line in meta.get_all("Project-URL") or []:
+                    if line.startswith("Homepage"):
+                        homepage = line.split(",", 1)[1].strip()
+                        break
+            return homepage or "no homepage found"
+        except Exception:
+            # Fallback
+            return self._get_pyproject_data()["project"]["urls"]["Homepage"]
+
+    def get_version(self) -> str:
+        return self.version
+
+    def get_version_info(self) -> str:
+        return f"""
+Metripy {self.get_version()}
+{self.url}
+"""
+
+    def get_help(self) -> str:
+        return (
+            self.get_version_info()
+            + """
+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,5 +1,8 @@
+from typing import Self
+
+
 class Dependency:
-    def __init__(self, name: str, version: str):
+    def __init__(self, name: str, version: str | None):
         self.name = name
         self.version = version
         self.latest: str = ""
@@ -28,3 +31,16 @@ class Dependency:
             "downloads_monthly": self.downloads_monthly,
             "licenses": ",".join(self.license),
         }
+
+    @staticmethod
+    def get_lisence_distribution(dependencies: list[Self]) -> dict[str, int]:
+        license_by_type = {}
+
+        dependency: Dependency
+        for dependency in dependencies:
+            for license_name in dependency.license:
+                if license_name not in license_by_type.keys():
+                    license_by_type[license_name] = 0
+                license_by_type[license_name] += 1
+
+        return license_by_type

metripy/Dependency/Pip/Pip.py

@@ -1,5 +1,4 @@
 import os
-import re
 
 import toml
 
@@ -23,47 +22,38 @@ class Pip:
         return [item for item in packages if item is not None]
 
     def get_from_requirements_txt(self, path: str) -> list[Dependency]:
-        requirements = []
-
-        pattern = re.compile(r"([a-zA-Z0-9_\-]+)([<>=!~]+[^\s]+)?")
         with open(os.path.join(path, "requirements.txt"), "r") as file:
             lines = file.readlines()
-            for line in lines:
+            return self._parse_dependencies(lines)
 
-                line = line.strip()
-                if line and not line.startswith("#"):
-                    match = pattern.match(line)
-                    if match:
-                        name = match.group(1)
-                        version = match.group(2) if match.group(2) else None
-                        requirements.append(Dependency(name, version))
-        return requirements
+        return []
 
     def get_from_pyproject_toml(self, path: str) -> list[Dependency]:
-        dependencies = []
-
         with open(os.path.join(path, "pyproject.toml"), "r") as f:
             data = toml.load(f)
 
             # For PEP 621 / setuptools projects
             if "project" in data:
                 deps = data["project"].get("dependencies", [])
-                for dep in deps:
-                    # dep is a string like "requests>=2.32.5"
-                    # You can split it if needed
-                    if "==" in dep:
-                        name, version = dep.split("==")
-                    elif ">=" in dep:
-                        name, version = dep.split(">=")
-                    else:
-                        name, version = dep, None
-                    dependencies.append(
-                        Dependency(name.strip(), version.strip() if version else None)
-                    )
+                return self._parse_dependencies(deps)
 
-        return dependencies
+        return []
 
+    def _parse_dependencies(self, lines: list[str]) -> list[Dependency]:
+        dependencies = []
+        for dep in lines:
+            dep = dep.strip()
+            if not dep or dep.startswith("#"):
+                continue
+            # dep is a string like "requests>=2.32.5"
+            if "==" in dep:
+                name, version = dep.split("==")
+            elif ">=" in dep:
+                name, version = dep.split(">=")
+            else:
+                name, version = dep, None
+            dependencies.append(
+                Dependency(name.strip(), version.strip() if version else None)
+            )
 
-if __name__ == "__main__":
-    pip = Pip()
-    pip.get_dependencies("./")
+        return dependencies

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)