metripy 0.2.7__tar.gz

metripy-0.2.7/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CodeMetrics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

metripy-0.2.7/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: metripy
+Version: 0.2.7
+Summary: A Python tool to generate multi project, multi language code metric reports
+Author-email: Yannick Zimmermann <yannick.zimmermann@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/zimmer-yan/codemetrics
+Project-URL: Repository, https://github.com/zimmer-yan/codemetrics
+Project-URL: Documentation, https://github.com/zimmer-yan/codemetrics#readme
+Project-URL: Bug Tracker, https://github.com/zimmer-yan/codemetrics/issues
+Keywords: code metrics,multi-language,code analysis,git metrics,code visualization,software quality,static analysis,repository insights,developer productivity,codebase health,technical debt,language-agnostic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lizard==1.18.0
+Requires-Dist: GitPython==3.1.45
+Requires-Dist: py-template-engine>=0.1.0
+Requires-Dist: radon==6.0.1
+Requires-Dist: requests==2.32.5
+Requires-Dist: packaging==25.0
+Requires-Dist: toml==0.10.2
+Requires-Dist: tree-sitter==0.21.3
+Requires-Dist: tree-sitter-languages==1.10.2
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov==7.0.0; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.991; extra == "dev"
+Requires-Dist: poethepoet==0.37.0; extra == "dev"
+Requires-Dist: isort==7.0.0; extra == "dev"
+Dynamic: license-file
+
+# Codemetrics
+A multilanguage, multi project code metrics analysis tool. 
+
+# Languages
+Supported languages
+- Python (with radon)
+- Php (experimental)
+- Typescript (experimental)
+- TBD
+
+# Analysis types
+
+## Code analysis
+Analyses code with cyclomatic complexity, maintainability index, halstead metrics.
+
+## Git analysis
+Analyses git stats of the past months
+
+## Dependeny analysis
+Analyzses composer, npm or pip dependencies
+
+More dependencies TBD
+
+# Report formats
+
+## Html
+Generates an easy to read dashboard
+
+TODO: as this application generates multi project reports, add central dashboard to have project specific insights at first glance
+
+## Csv
+Coming soon...
+
+## Json
+Coming soon...
+
+## Cli
+Coming soon...
+
+# Configuration
+Configuration is for the moment only possible with the `--config=<file>.json` option. More TBD
+
+Sample configuraiton:
+```json
+{
+    "configs": {
+        "metripy": {
+            "base_path": "./", // base path to look at
+            "includes": [
+                "metripy/" // paths to include from the base path on
+            ],
+            "excludes": [
+                "__pycache__" // exclude patterns of paths / files
+            ],
+            "extensions": [
+                "py" // file extensions to look at
+            ],
+            "git": { // if git is set, analyzes git history
+                "branch": "main" // git branch to look at
+            },
+            "composer": true, // looks for base_path/composer.json and analyzes dependencies - for php projects
+            "npm": true, // looks for base_path/package.json and analyzes dependencies - for ts/js projects
+            "pip": true,
+            // looks for base_path/requirements.txt or base_path/pyproject.toml and analyzes dependencies - for python projects
+            "reports": {
+                "html": "./build/report/codemetrics", // report should be put into this directory
+                "json-git": "./build/json-report/codemetrics-git.json" // file where to put git json report
+                // more types of reports TBA
+            }
+        },
+        // next project name: { next config... } 
+    }
+}
+```

metripy-0.2.7/README.md

@@ -0,0 +1,74 @@
+# Codemetrics
+A multilanguage, multi project code metrics analysis tool. 
+
+# Languages
+Supported languages
+- Python (with radon)
+- Php (experimental)
+- Typescript (experimental)
+- TBD
+
+# Analysis types
+
+## Code analysis
+Analyses code with cyclomatic complexity, maintainability index, halstead metrics.
+
+## Git analysis
+Analyses git stats of the past months
+
+## Dependeny analysis
+Analyzses composer, npm or pip dependencies
+
+More dependencies TBD
+
+# Report formats
+
+## Html
+Generates an easy to read dashboard
+
+TODO: as this application generates multi project reports, add central dashboard to have project specific insights at first glance
+
+## Csv
+Coming soon...
+
+## Json
+Coming soon...
+
+## Cli
+Coming soon...
+
+# Configuration
+Configuration is for the moment only possible with the `--config=<file>.json` option. More TBD
+
+Sample configuraiton:
+```json
+{
+    "configs": {
+        "metripy": {
+            "base_path": "./", // base path to look at
+            "includes": [
+                "metripy/" // paths to include from the base path on
+            ],
+            "excludes": [
+                "__pycache__" // exclude patterns of paths / files
+            ],
+            "extensions": [
+                "py" // file extensions to look at
+            ],
+            "git": { // if git is set, analyzes git history
+                "branch": "main" // git branch to look at
+            },
+            "composer": true, // looks for base_path/composer.json and analyzes dependencies - for php projects
+            "npm": true, // looks for base_path/package.json and analyzes dependencies - for ts/js projects
+            "pip": true,
+            // looks for base_path/requirements.txt or base_path/pyproject.toml and analyzes dependencies - for python projects
+            "reports": {
+                "html": "./build/report/codemetrics", // report should be put into this directory
+                "json-git": "./build/json-report/codemetrics-git.json" // file where to put git json report
+                // more types of reports TBA
+            }
+        },
+        // next project name: { next config... } 
+    }
+}
+```

metripy-0.2.7/metripy/Application/Analyzer.py

@@ -0,0 +1,106 @@
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+from metripy.Component.Debug.Debugger import Debugger
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Component.Output.ProgressBar import ProgressBar
+from metripy.Dependency.Composer.Composer import Composer
+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.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.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.Git.GitMetrics import GitMetrics
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+
+
+class Analyzer:
+    def __init__(self, config: ProjectConfig, output: CliOutput, debugger: Debugger):
+        self.config = config
+        self.output = output
+        self.debugger = debugger
+        self.runners: list[AbstractLangAnalyzer] = [
+            PythonAnalyzer(),
+            PhpAnalyzer(),
+            TypescriptAnalyzer(),
+        ]
+
+    def analyze_git(self) -> GitMetrics:
+        self.output.writeln("<info>Analyzing git history...</info>")
+        metrics = GitAnalyzer(self.config.git).analyze()
+        self.output.writeln("<success>Git history analyzed</success>")
+
+        return metrics
+
+    def analyze_code(self, files: list[str]) -> list[FileMetrics]:
+        file_metrics = []
+
+        # for multi language projects, register runner per language
+        runner_sizes = []
+        for runner in self.runners:
+            runner.set_files(files)
+            if not runner.is_needed():
+                continue
+            runner_sizes.append(len(runner.files))
+
+        self.debugger.debug(len(files))
+        self.output.writeln("<info>Analyzing code...</info>")
+        progress_bar = ProgressBar(self.output, sum(runner_sizes))
+        for runner in self.runners:
+            if not runner.is_needed():
+                continue
+            runner.before_run()
+            runner.run(progress_bar)
+            runner.after_run()
+
+            for metric in runner.get_metrics():
+                file_metrics.append(metric)
+
+        self.output.writeln("")
+        self.output.writeln("<success>Code analyzed</success>")
+
+        return file_metrics
+
+    def analyze_composer(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing composer packages...</info>")
+        dependencies = Composer().get_composer_dependencies(self.config.base_path)
+        self.output.writeln("<success>Composer packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_pip(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing pip packages...</info>")
+        dependencies = Pip().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Pip packages analyzed</success>")
+
+        return dependencies
+
+    def analyze_npm(self) -> list[Dependency]:
+        self.output.writeln("<info>Analyzing npm packages...</info>")
+        dependencies = Npm().get_dependencies(self.config.base_path)
+        self.output.writeln("<success>Npm packages analyzed</success>")
+
+        return dependencies
+
+    def run(self, files: list[str]) -> ProjectMetrics:
+        git_stats = None
+        if self.config.git:
+            git_stats = self.analyze_git()
+
+        file_metrics = []
+        if True:
+            file_metrics = self.analyze_code(files)
+
+        # TODO: analyze dependencies: composer, pip, npm, etc etc
+        packages = None
+        if self.config.composer:
+            packages = self.analyze_composer()
+        elif self.config.pip:
+            packages = self.analyze_pip()
+        elif self.config.npm:
+            packages = self.analyze_npm()
+
+        return ProjectMetrics(file_metrics, git_stats, packages)

metripy-0.2.7/metripy/Application/Application.py

@@ -0,0 +1,54 @@
+import json
+
+from metripy.Application.Analyzer import Analyzer
+from metripy.Application.Config.Parser import Parser
+from metripy.Component.Debug.Debugger import Debugger
+from metripy.Component.File.Finder import Finder
+from metripy.Component.Output.CliOutput import CliOutput
+from metripy.Report.ReporterFactory import ReporterFactory
+from metripy.Report.ReporterInterface import ReporterInterface
+
+
+class Application:
+    def run(self, argv) -> None:
+        output = CliOutput()
+
+        # issues and debug
+        debugger = Debugger(output).enable()
+
+        config = Parser().parse(argv)
+
+        finder = Finder()
+        files = finder.fetch(config.project_configs)
+
+        for project_config in config.project_configs:
+            debugger.debug(project_config.name)
+            project_files = files[project_config.name]
+            debugger.debug(f"Found {len(project_files)} files")
+            debugger.debug(json.dumps(project_files))
+
+            output.writeln(f"<info>Analying Project {project_config.name}...</info>")
+            project_metrics = Analyzer(project_config, output, debugger).run(
+                project_files
+            )
+            output.writeln(
+                f"<success>Done analying Project {project_config.name}</success>"
+            )
+
+            if not project_config.reports:
+                output.writeln(
+                    f"<success>Skipping reports of {project_config.name}!</success>"
+                )
+                continue
+
+            output.writeln(
+                f"<info>Generating reports for {project_config.name}...</info>"
+            )
+            for report_config in project_config.reports:
+                reporter: ReporterInterface = ReporterFactory.create(
+                    report_config, output
+                )
+                reporter.generate(project_metrics)
+            output.writeln(
+                f"<success>Reports generated for {project_config.name}</success>"
+            )

metripy-0.2.7/metripy/Application/Config/Config.py

@@ -0,0 +1,13 @@
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+
+
+class Config:
+    def __init__(self):
+        self.project_configs: list[ProjectConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "project_configs": [
+                project_config.to_dict() for project_config in self.project_configs
+            ],
+        }

metripy-0.2.7/metripy/Application/Config/File/ConfigFileReaderFactory.py

@@ -0,0 +1,24 @@
+import os
+import pathlib
+
+from metripy.Application.Config.File.ConfigFileReaderInterface import \
+    ConfigFileReaderInterface
+from metripy.Application.Config.File.JsonConfigFileReader import \
+    JsonConfigFileReader
+
+
+class ConfigFileReaderFactory:
+    @staticmethod
+    def createFromFileName(filename: str) -> ConfigFileReaderInterface:
+        if not os.path.isfile(filename):
+            raise FileNotFoundError(f"File {filename} does not exist")
+
+        extension = pathlib.Path(filename).suffix
+        if extension == ".json":
+            return JsonConfigFileReader(filename)
+        elif extension == ".yaml" or extension == ".yml":
+            raise NotImplementedError("YAML support is not implemented yet")
+        elif extension == ".xml":
+            raise NotImplementedError("XML support is not implemented yet")
+        else:
+            raise NotImplementedError(f"Unsupported file type: {extension}")

metripy-0.2.7/metripy/Application/Config/File/ConfigFileReaderInterface.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from metripy.Application.Config.Config import Config
+
+
+class ConfigFileReaderInterface(ABC):
+
+    @abstractmethod
+    def __init__(self, filename: str):
+        pass
+
+    @abstractmethod
+    def read(self, config: Config) -> None:
+        pass

metripy-0.2.7/metripy/Application/Config/File/JsonConfigFileReader.py

@@ -0,0 +1,82 @@
+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
+
+
+class JsonConfigFileReader(ConfigFileReaderInterface):
+    def __init__(self, filename: str):
+        self.filename = 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

metripy-0.2.7/metripy/Application/Config/GitConfig.py

@@ -0,0 +1,10 @@
+class GitConfig:
+    def __init__(self):
+        self.repo = "./"
+        self.branch = "main"
+
+    def to_dict(self) -> dict:
+        return {
+            "repo": self.repo,
+            "branch": self.branch,
+        }

metripy-0.2.7/metripy/Application/Config/Parser.py

@@ -0,0 +1,31 @@
+import re
+
+from metripy.Application.Config.Config import Config
+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)
+
+        # check for a config file
+        for key, arg in enumerate(argv):
+            if matches := re.search(r"^--config=(.+)$", arg):
+                fileReader = ConfigFileReaderFactory.createFromFileName(
+                    matches.group(1)
+                )
+                fileReader.read(config)
+                argv.pop(key)
+
+        # TODO: add the following
+        # arguments with options
+        # arguments without options
+        # last argument
+
+        return config

metripy-0.2.7/metripy/Application/Config/ProjectConfig.py

@@ -0,0 +1,27 @@
+from metripy.Application.Config.GitConfig import GitConfig
+from metripy.Application.Config.ReportConfig import ReportConfig
+
+
+class ProjectConfig:
+    def __init__(self, name: str):
+        self.name: str = name
+        self.base_path: str = "./"
+        self.includes: list[str] = []
+        self.excludes: list[str] = []
+        self.extensions: list[str] = []
+        self.git: GitConfig | None = None
+        self.composer: bool = False
+        self.pip: bool = False
+        self.npm: bool = False
+        self.reports: list[ReportConfig] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "base_path": self.base_path,
+            "includes": self.includes,
+            "excludes": self.excludes,
+            "extensions": self.extensions,
+            "git": self.git.to_dict() if self.git else None,
+            "reports": [report.to_dict() for report in self.reports],
+        }

metripy-0.2.7/metripy/Application/Config/ReportConfig.py

@@ -0,0 +1,10 @@
+class ReportConfig:
+    def __init__(self, report_type: str, path: str) -> None:
+        self.type = report_type
+        self.path = path
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type,
+            "path": self.path,
+        }

metripy-0.2.7/metripy/Component/Debug/Debugger.py

@@ -0,0 +1,20 @@
+from typing import Self
+
+from metripy.Component.Output.CliOutput import CliOutput
+
+
+class Debugger:
+    def __init__(self, output: CliOutput):
+        self.enabled = False
+        self.output = output
+
+    def enable(self) -> Self:
+        self.enabled = True
+
+        return self
+
+    def debug(self, message: str):
+        if not self.enabled:
+            return
+
+        self.output.writeln(f"<debug>{message}</debug>")

metripy-0.2.7/metripy/Component/File/Finder.py

@@ -0,0 +1,37 @@
+import os
+
+from metripy.Application.Config.ProjectConfig import ProjectConfig
+
+
+class Finder:
+    def fetch(self, project_configs: list[ProjectConfig]) -> dict[str, list[str]]:
+        """returns a list of files per project project_name => [files,...]"""
+        project_files = {}
+        for project_config in project_configs:
+            files = []
+
+            paths = [
+                os.path.join(project_config.base_path, inc)
+                for inc in project_config.includes
+            ]
+            for path in paths:
+                if os.path.isdir(path):
+                    self._search(
+                        path, project_config.extensions, project_config.excludes, files
+                    )
+            project_files[project_config.name] = files
+
+        return project_files
+
+    def _search(
+        self, path: str, extensions: list[str], excludes: list[str], results: list[str]
+    ):
+        if not os.path.isdir(path):
+            if path not in excludes and path.endswith(tuple(extensions)):
+                results.append(path)
+
+        for file in os.listdir(path):
+            if os.path.isdir(os.path.join(path, file)) and file not in excludes:
+                self._search(os.path.join(path, file), extensions, excludes, results)
+            elif file not in excludes and file.endswith(tuple(extensions)):
+                results.append(os.path.join(path, file))