fix: add missing helpers_proxy
This commit is contained in:
cclecle
1
helpers/.gitignore
vendored
1
helpers/.gitignore
vendored
@@ -1 +0,0 @@
|
||||
/.mypy_cache/
|
||||
@@ -1,7 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
@@ -1,108 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from pathlib import Path
|
||||
import tomli
|
||||
import argparse
|
||||
import os
|
||||
import logging
|
||||
import sys
|
||||
|
||||
if __package__ == "helpers":
|
||||
# when calling the module from: > python -m helpers
|
||||
from .types_check import types_check
|
||||
from .quality_check import quality_check
|
||||
from .unit_test import unit_test
|
||||
from .doc_gen import doc_gen
|
||||
from .complexity_check import complexity_check
|
||||
else:
|
||||
# when calling the __main__.py file (from IDE)
|
||||
from helpers.types_check import types_check
|
||||
from helpers.quality_check import quality_check
|
||||
from helpers.unit_test import unit_test
|
||||
from helpers.doc_gen import doc_gen
|
||||
from helpers.complexity_check import complexity_check
|
||||
|
||||
logging.getLogger().setLevel(logging.INFO)
|
||||
|
||||
if __name__ == "__main__":
|
||||
project_rootdir_path = Path(__file__).parent.parent.absolute()
|
||||
|
||||
with open(project_rootdir_path / "pyproject.toml", mode="rb") as fp:
|
||||
pyproject = tomli.load(fp)
|
||||
|
||||
parser = argparse.ArgumentParser(
|
||||
prog="continuous-integration-helper", description="A tiny set of scripts to help continous integration on python"
|
||||
)
|
||||
|
||||
parser.add_argument("-tc", "--type-check", dest="typecheck", action="store_true", help="enable static typing check")
|
||||
|
||||
parser.add_argument("-ut", "--unit-test", dest="unittest", action="store_true", help="enable unit-test")
|
||||
parser.add_argument(
|
||||
"-cc", "--coverage-check", dest="coveragecheck", action="store_true", help="enable unit-test coverage check (requires unit-test)"
|
||||
)
|
||||
|
||||
parser.add_argument("-qc", "--quality-check", dest="qualitycheck", action="store_true", help="enable code quality check")
|
||||
|
||||
parser.add_argument("-dg", "--doc-gen", dest="docgen", action="store_true", help="enable documentation generation using MkDoc")
|
||||
parser.add_argument(
|
||||
"-pdf", "--doc-gen-pdf", dest="docgenpdf", action="store_true", help="enable pdf documentation export (requires doc-gen)"
|
||||
)
|
||||
|
||||
parser.add_argument("-cpc", "--complexity-check", dest="complexitycheck", action="store_true", help="enable complexity check")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
##################################
|
||||
# Dev / Debug forced toogles
|
||||
#
|
||||
# --------------------------------
|
||||
#
|
||||
# args.typecheck = True
|
||||
# args.qualitycheck = True
|
||||
# args.unittest = True
|
||||
# args.coveragecheck = True
|
||||
# args.docgen = True
|
||||
# args.docgenpdf = True
|
||||
# args.complexitycheck = True
|
||||
|
||||
helpers = []
|
||||
if args.typecheck == True:
|
||||
helpers.append(types_check)
|
||||
|
||||
if args.unittest == True:
|
||||
helpers.append(unit_test)
|
||||
|
||||
if args.coveragecheck == True:
|
||||
if args.unittest == True:
|
||||
unit_test.enable_coverage_check = True
|
||||
else:
|
||||
raise RuntimeError("unit-test is required to enable coverage-check")
|
||||
|
||||
if args.qualitycheck == True:
|
||||
helpers.append(quality_check)
|
||||
|
||||
if args.docgen == True:
|
||||
helpers.append(doc_gen)
|
||||
|
||||
if args.docgenpdf == True:
|
||||
if args.docgen == True:
|
||||
doc_gen.enable_gen_pdf = True
|
||||
else:
|
||||
raise RuntimeError("doc-gen is required to enable doc-gen-pdf")
|
||||
|
||||
if args.complexitycheck == True:
|
||||
helpers.append(complexity_check)
|
||||
|
||||
for helper in helpers:
|
||||
helper.set_context(project_rootdir_path, pyproject)
|
||||
helper.reset_result_dir()
|
||||
helper.do_job()
|
||||
@@ -1,70 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
# from pathlib import Path
|
||||
# import os
|
||||
import statistics
|
||||
import csv
|
||||
from json import loads as JSON_LOADS
|
||||
from radon.complexity import cc_rank, SCORE
|
||||
from radon.cli import Config
|
||||
from radon.cli.harvest import CCHarvester, HCHarvester, MIHarvester
|
||||
|
||||
from .helper_base import helper_withresults_base
|
||||
from pprint import pprint
|
||||
|
||||
|
||||
class complexity_check(helper_withresults_base):
|
||||
@classmethod
|
||||
def do_job(cls):
|
||||
config = Config(
|
||||
exclude="__init__\.py",
|
||||
ignore=None,
|
||||
order=SCORE,
|
||||
show_closures=False,
|
||||
no_assert=True,
|
||||
min="A",
|
||||
max="F",
|
||||
multi=False,
|
||||
)
|
||||
|
||||
h = MIHarvester([str(_) for _ in sorted((cls.project_rootdir_path / "src").rglob("*.py"))], config).as_json()
|
||||
res = JSON_LOADS(h)
|
||||
|
||||
with open(cls.get_result_dir() / "MI.json", "w", newline="") as oFile:
|
||||
oFile.write(h)
|
||||
|
||||
mean = statistics.mean(_["mi"] for _ in res.values())
|
||||
|
||||
if mean >= 65:
|
||||
rank = "A+"
|
||||
elif mean >= 20:
|
||||
rank = "A"
|
||||
elif mean >= 10:
|
||||
rank = "B"
|
||||
else:
|
||||
rank = "C"
|
||||
|
||||
RES_MI = {"MeanMaintainability": mean, "MaintainabilityIndex": rank}
|
||||
with open(cls.get_result_dir() / "MI.csv", "w", newline="") as oFile:
|
||||
writer = csv.DictWriter(oFile, fieldnames=RES_MI.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(RES_MI)
|
||||
|
||||
config = Config(exclude=None, ignore=None, order=SCORE, show_closures=False, no_assert=True, min="A", max="F", multi=False)
|
||||
h = CCHarvester([str(_) for _ in sorted((cls.project_rootdir_path / "src").rglob("*.py"))], config).as_json()
|
||||
with open(cls.get_result_dir() / "CC.json", "w", newline="") as oFile:
|
||||
oFile.write(h)
|
||||
|
||||
config = Config(exclude=None, ignore=None, order=SCORE, show_closures=False, no_assert=True, min="A", max="F", by_function=None)
|
||||
h = HCHarvester([str(_) for _ in sorted((cls.project_rootdir_path / "src").rglob("*.py"))], config).as_json()
|
||||
with open(cls.get_result_dir() / "HC.json", "w", newline="") as oFile:
|
||||
oFile.write(h)
|
||||
@@ -1,98 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
import shutil
|
||||
import os
|
||||
import sys
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
from distutils.dir_util import copy_tree
|
||||
|
||||
import yaml
|
||||
|
||||
try:
|
||||
from yaml import CLoader as Loader, CDumper as Dumper
|
||||
except ImportError:
|
||||
from yaml import Loader, Dumper
|
||||
|
||||
from .helper_base import helper_withresults_base
|
||||
|
||||
|
||||
class doc_gen(helper_withresults_base):
|
||||
enable_gen_pdf: bool = False
|
||||
|
||||
@classmethod
|
||||
def do_job(cls):
|
||||
|
||||
# create doc root dir
|
||||
doc_path = cls.project_rootdir_path / "docs"
|
||||
cls._reset_dir(doc_path)
|
||||
|
||||
site_path = cls.get_result_dir() / "site"
|
||||
cls._reset_dir(site_path)
|
||||
|
||||
# copy files from main project dir
|
||||
shutil.copyfile(str(cls.project_rootdir_path / "README.md"), str(doc_path / "README.md"))
|
||||
shutil.copyfile(str(cls.project_rootdir_path / "LICENSE.md"), str(doc_path / "LICENSE.md"))
|
||||
|
||||
# copy files from static-doc dir
|
||||
copy_tree(str(cls.project_rootdir_path / "docs-static"), str(doc_path))
|
||||
|
||||
# generating API doc + nav from python docstrings
|
||||
reference_path = doc_path / "reference"
|
||||
cls._reset_dir(reference_path)
|
||||
|
||||
# create one .md per python module
|
||||
for path in sorted((cls.project_rootdir_path / "src").rglob("*.py")):
|
||||
module_path = path.relative_to(cls.project_rootdir_path / "src").with_suffix("")
|
||||
doc_path = path.relative_to(cls.project_rootdir_path / "src").with_suffix(".md")
|
||||
full_doc_path = Path(reference_path, doc_path)
|
||||
|
||||
parts = list(module_path.parts)
|
||||
|
||||
if parts[-1] in ("__init__", "__main__"):
|
||||
continue
|
||||
|
||||
cls._create_dir(full_doc_path.parent.resolve())
|
||||
with open(full_doc_path, "w+") as fd:
|
||||
identifier = ".".join(parts)
|
||||
print("::: " + identifier, file=fd)
|
||||
|
||||
cmdopts = [f"{sys.executable}", "-m", "mkdocs", "-v", "build", "--site-dir", str(site_path), "--clean"]
|
||||
|
||||
# little hack here, to enable / disable pdf generation using own class config
|
||||
# => reason is mkdocs seems to try loading the plugin even if we disable it, so we need to
|
||||
# manually process the configuration file.
|
||||
with open(cls.project_rootdir_path / "mkdocs.yml", "r") as mkdocsCfgFile:
|
||||
mkdocsCfg = yaml.load(mkdocsCfgFile, Loader=yaml.Loader)
|
||||
|
||||
if "plugins" in mkdocsCfg:
|
||||
mkdocsCfg["plugins"] = [_ for _ in mkdocsCfg["plugins"] if (not isinstance(_, dict) or "with-pdf" not in _.keys())]
|
||||
|
||||
if cls.enable_gen_pdf == True:
|
||||
mkdocsCfg["plugins"].append(
|
||||
{
|
||||
"with-pdf": {
|
||||
"cover_subtitle": "User Manual",
|
||||
"cover_logo": str(cls.project_rootdir_path / "docs-static" / "Library.jpg"),
|
||||
"verbose": False,
|
||||
"exclude_pages": ["LICENSE"],
|
||||
"output_path": str(site_path / "pdf" / "manual.pdf"),
|
||||
}
|
||||
}
|
||||
)
|
||||
with open(cls.project_rootdir_path / "mkdocs.yml", "w") as mkdocsCfgFile:
|
||||
mkdocsCfgFile.write(yaml.dump(mkdocsCfg, Dumper=Dumper, default_flow_style=False, sort_keys=False))
|
||||
|
||||
print(" !! start doc generation")
|
||||
res = cls.run_cmd(cmdopts)
|
||||
print(res.decode())
|
||||
print(" !! done")
|
||||
@@ -1,82 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
import os
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
if TYPE_CHECKING: # Only imports the below statements during type checking
|
||||
from typing import Union
|
||||
|
||||
|
||||
class helper_base(ABC):
|
||||
project_rootdir_path: Union[Path, None] = None
|
||||
pyproject: Union[dict, None] = None
|
||||
current_dir: Union[Path, None] = None
|
||||
|
||||
@classmethod
|
||||
def set_context(cls, project_rootdir_path: Path, pyproject: dict):
|
||||
cls.project_rootdir_path = project_rootdir_path
|
||||
cls.pyproject = pyproject
|
||||
cls.current_dir = Path(__file__).parent.absolute()
|
||||
|
||||
@classmethod
|
||||
def get_result_dir(cls):
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def _create_dir(dirpath: Path):
|
||||
dirpath = Path(dirpath)
|
||||
if not os.path.exists(dirpath):
|
||||
os.makedirs(dirpath)
|
||||
|
||||
@staticmethod
|
||||
def _reset_dir(dirpath: Path):
|
||||
dirpath = Path(dirpath)
|
||||
if os.path.exists(dirpath):
|
||||
shutil.rmtree(dirpath)
|
||||
os.makedirs(dirpath)
|
||||
|
||||
@classmethod
|
||||
def reset_result_dir(cls):
|
||||
result_dir = cls.get_result_dir()
|
||||
if result_dir != None:
|
||||
cls._reset_dir(result_dir)
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def do_job(cls):
|
||||
raise NotImplementedError()
|
||||
|
||||
@classmethod
|
||||
def run_cmd_(cls, cmdarray):
|
||||
process = subprocess.run(cmdarray, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, check=True)
|
||||
return process.stdout
|
||||
|
||||
@classmethod
|
||||
def run_cmd(cls, cmdarray, silent: bool = False):
|
||||
p = subprocess.run(cmdarray, capture_output=True)
|
||||
if not silent:
|
||||
print(p.stdout.decode())
|
||||
print(p.stderr.decode())
|
||||
return p.stdout
|
||||
|
||||
|
||||
class helper_withresults_base(helper_base):
|
||||
helper_results_dir: Union[Path, None] = None
|
||||
|
||||
@classmethod
|
||||
def get_result_dir(cls):
|
||||
if cls.helper_results_dir == None:
|
||||
cls.helper_results_dir = cls.__name__
|
||||
return Path(__file__).parent.parent.absolute() / "helpers-results" / cls.helper_results_dir
|
||||
@@ -1,247 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from contextlib import redirect_stdout
|
||||
from io import StringIO
|
||||
import re
|
||||
import json
|
||||
from enum import Enum
|
||||
from contextlib import suppress
|
||||
import sys
|
||||
import pandas
|
||||
import csv
|
||||
import copy
|
||||
|
||||
from pylint.lint import Run as pylint_Run
|
||||
import pylint_json2html
|
||||
|
||||
from .helper_base import helper_withresults_base
|
||||
|
||||
|
||||
class PyLintMetricNotFound(Warning):
|
||||
pass
|
||||
|
||||
|
||||
class quality_check(helper_withresults_base):
|
||||
PylintMessageList = dict()
|
||||
|
||||
@classmethod
|
||||
def GetPylintMessageList(cls):
|
||||
Messagelist = dict()
|
||||
regex = r"^:([a-zA-Z-]+) \(([^\)]+)\)"
|
||||
for line in cls.run_cmd([sys.executable, "-m", "pylint", "--list-msgs"], True).splitlines():
|
||||
if res := re.search(regex, line.decode()):
|
||||
Messagelist[res.group(1)] = res.group(2)
|
||||
cls.PylintMessageList = Messagelist
|
||||
|
||||
@staticmethod
|
||||
def TryExtractPYReportMetric(line: str, tag: str):
|
||||
regex = f"^(?:\|{tag}\s*\|)(\d+)(?=\s*|)"
|
||||
if res := re.search(regex, line):
|
||||
return float(res.group(1))
|
||||
raise PyLintMetricNotFound()
|
||||
|
||||
@classmethod
|
||||
def do_job(cls):
|
||||
print("checking code quality ...")
|
||||
|
||||
cls.GetPylintMessageList()
|
||||
|
||||
RES_all = dict()
|
||||
with StringIO() as StdOutput:
|
||||
JsonContent = ""
|
||||
with redirect_stdout(StdOutput):
|
||||
pylint_Run(
|
||||
[
|
||||
"--load-plugins=pylint.extensions.mccabe",
|
||||
"--output-format=json,parseable",
|
||||
"--disable=invalid-name,too-few-public-methods,too-many-arguments", # ignore
|
||||
"--ignore=_version.py",
|
||||
"--reports=y",
|
||||
"--score=yes",
|
||||
"--max-line-length=140",
|
||||
"src." + cls.pyproject["project"]["name"],
|
||||
],
|
||||
exit=False,
|
||||
)
|
||||
|
||||
with open(cls.get_result_dir() / "report.json", "w+", encoding="utf-8") as Outfile:
|
||||
# hacky way of exctracting json + having overall score...
|
||||
class TScanState(Enum):
|
||||
TEXT_REPORT = 1
|
||||
JSON_REPORT = 2
|
||||
OTHER_REPORT_START = 3
|
||||
OTHER_REPORT_STATISTICS = 4
|
||||
OTHER_REPORT_METRICS = 5
|
||||
OTHER_REPORT_DUPLICATION = 6
|
||||
OTHER_REPORT_MESSAGES_CAT = 7
|
||||
OTHER_REPORT_MESSAGES = 8
|
||||
OTHER_REPORT_END = 99
|
||||
|
||||
RES_all["Statistics"] = dict()
|
||||
RES_all["RawMetrics"] = dict()
|
||||
RES_all["RawMetricsPercent"] = dict()
|
||||
RES_all["Duplication"] = dict()
|
||||
RES_all["MessagesCat"] = dict()
|
||||
RES_all["Messages"] = dict()
|
||||
RES_all["GlobalScore"] = -999
|
||||
RES_all["NbAnalysedStatments"] = -999
|
||||
RES_all["NbAnalysedLines"] = -999
|
||||
|
||||
ScanState = TScanState.TEXT_REPORT
|
||||
for line in StdOutput.getvalue().split("\n"):
|
||||
print(line)
|
||||
if ScanState == TScanState.TEXT_REPORT:
|
||||
# ignoring this part, we need json
|
||||
if line == "[":
|
||||
JsonContent += line
|
||||
ScanState = TScanState.JSON_REPORT
|
||||
elif line == "[]":
|
||||
JsonContent += line
|
||||
ScanState = TScanState.OTHER_REPORT_START
|
||||
|
||||
elif ScanState == TScanState.JSON_REPORT:
|
||||
JsonContent += line
|
||||
if line == "]":
|
||||
ScanState = TScanState.OTHER_REPORT_START
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_START:
|
||||
if res := re.search(r"^(\d+)(?= statements analysed.)", line):
|
||||
RES_all["NbAnalysedStatments"] = float(res.group(1))
|
||||
if line == "Statistics by type":
|
||||
ScanState = TScanState.OTHER_REPORT_STATISTICS
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_STATISTICS:
|
||||
if res := re.search(r"^(\d+)(?= lines have been analyzed)", line):
|
||||
RES_all["NbAnalysedLines"] = float(res.group(1))
|
||||
elif line == "Raw metrics":
|
||||
ScanState = TScanState.OTHER_REPORT_METRICS
|
||||
else:
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Statistics"]["module"] = cls.TryExtractPYReportMetric(line, "module")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Statistics"]["class"] = cls.TryExtractPYReportMetric(line, "class")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Statistics"]["method"] = cls.TryExtractPYReportMetric(line, "method")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Statistics"]["function"] = cls.TryExtractPYReportMetric(line, "function")
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_METRICS:
|
||||
if line == "Duplication":
|
||||
RES_all["RawMetricsPercent"]["code"] = RES_all["RawMetrics"]["code"] / RES_all["NbAnalysedLines"]
|
||||
RES_all["RawMetricsPercent"]["docstring"] = RES_all["RawMetrics"]["docstring"] / RES_all["NbAnalysedLines"]
|
||||
RES_all["RawMetricsPercent"]["comment"] = RES_all["RawMetrics"]["comment"] / RES_all["NbAnalysedLines"]
|
||||
RES_all["RawMetricsPercent"]["empty"] = RES_all["RawMetrics"]["empty"] / RES_all["NbAnalysedLines"]
|
||||
ScanState = TScanState.OTHER_REPORT_DUPLICATION
|
||||
else:
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["RawMetrics"]["code"] = cls.TryExtractPYReportMetric(line, "code")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["RawMetrics"]["docstring"] = cls.TryExtractPYReportMetric(line, "docstring")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["RawMetrics"]["comment"] = cls.TryExtractPYReportMetric(line, "comment")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["RawMetrics"]["empty"] = cls.TryExtractPYReportMetric(line, "empty")
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_DUPLICATION:
|
||||
if line == "Messages by category":
|
||||
ScanState = TScanState.OTHER_REPORT_MESSAGES_CAT
|
||||
else:
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Duplication"]["NbDupLines"] = cls.TryExtractPYReportMetric(line, "nb duplicated lines")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Duplication"]["PersentDuplicatedLines"] = cls.TryExtractPYReportMetric(
|
||||
line, "percent duplicated lines"
|
||||
)
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_MESSAGES_CAT:
|
||||
if line == "Messages":
|
||||
ScanState = TScanState.OTHER_REPORT_MESSAGES
|
||||
else:
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["MessagesCat"]["Convention"] = cls.TryExtractPYReportMetric(line, "convention")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["MessagesCat"]["Refactor"] = cls.TryExtractPYReportMetric(line, "refactor")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["MessagesCat"]["Warning"] = cls.TryExtractPYReportMetric(line, "warning")
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["MessagesCat"]["Error"] = cls.TryExtractPYReportMetric(line, "error")
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_MESSAGES:
|
||||
# approx match because the number of '-' depend on screen width..
|
||||
if line.startswith("--------"):
|
||||
ScanState = TScanState.OTHER_REPORT_END
|
||||
else:
|
||||
for PylintMessage in cls.PylintMessageList.keys():
|
||||
with suppress(PyLintMetricNotFound):
|
||||
RES_all["Messages"][PylintMessage] = cls.TryExtractPYReportMetric(line, PylintMessage)
|
||||
|
||||
elif ScanState == TScanState.OTHER_REPORT_END:
|
||||
if res := re.search(r"(?<=Your code has been rated at )(\d+(?:\.\d+)?)/10", line):
|
||||
RES_all["GlobalScore"] = float(res.group(1))
|
||||
print(RES_all["GlobalScore"])
|
||||
else:
|
||||
raise RuntimeError("Invalid ScanState")
|
||||
Outfile.write(JsonContent)
|
||||
|
||||
with open(cls.get_result_dir() / "metrics.json", "w") as json_file:
|
||||
json.dump(RES_all, json_file)
|
||||
|
||||
# exporting all Data in one csv, unused atm because jenkins seems not able to select columns from csv an keep displaying all...
|
||||
# => to export a working full csv we need to a 'flat' dict (no more nested dict)
|
||||
RES_all_trim = copy.deepcopy(RES_all)
|
||||
del RES_all_trim["Messages"]
|
||||
flat_RES_all = pandas.json_normalize(RES_all_trim, sep="_").to_dict(orient="records")[0]
|
||||
|
||||
with open(cls.get_result_dir() / "metrics.csv", "w", newline="") as csv_file:
|
||||
writer = csv.DictWriter(csv_file, fieldnames=flat_RES_all.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(flat_RES_all)
|
||||
|
||||
# splited csv exports for jenkins plots: RawMetricsPercent
|
||||
RES_all_percent = RES_all["RawMetricsPercent"]
|
||||
with open(cls.get_result_dir() / "metrics_rawpercent.csv", "w", newline="") as csv_file:
|
||||
writer = csv.DictWriter(csv_file, fieldnames=RES_all_percent.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(RES_all_percent)
|
||||
|
||||
# splited csv exports for jenkins plots: Statistics + Duplication + NbAnalysedStatments + NbAnalysedLines
|
||||
RES_all_stats = copy.deepcopy(RES_all["Statistics"])
|
||||
RES_all_stats["NbDupLines"] = RES_all["Duplication"]["NbDupLines"]
|
||||
RES_all_stats["PersentDuplicatedLines"] = RES_all["Duplication"]["PersentDuplicatedLines"]
|
||||
RES_all_stats["NbAnalysedStatments"] = RES_all["NbAnalysedStatments"]
|
||||
RES_all_stats["NbAnalysedLines"] = RES_all["NbAnalysedLines"]
|
||||
with open(cls.get_result_dir() / "metrics_Statistics.csv", "w", newline="") as csv_file:
|
||||
writer = csv.DictWriter(csv_file, fieldnames=RES_all_stats.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(RES_all_stats)
|
||||
|
||||
# splited csv exports for jenkins plots: Statistics + Duplication
|
||||
RES_all_MessagesCat = RES_all["MessagesCat"]
|
||||
with open(cls.get_result_dir() / "metrics_MessagesCat.csv", "w", newline="") as csv_file:
|
||||
writer = csv.DictWriter(csv_file, fieldnames=RES_all_MessagesCat.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(RES_all_MessagesCat)
|
||||
|
||||
# splited csv exports for jenkins plots: GlobalScore
|
||||
RES_GlobalScore = {"GlobalScore": RES_all["GlobalScore"]}
|
||||
with open(cls.get_result_dir() / "metrics_GlobalScore.csv", "w", newline="") as csv_file:
|
||||
writer = csv.DictWriter(csv_file, fieldnames=RES_GlobalScore.keys())
|
||||
writer.writeheader()
|
||||
writer.writerow(RES_GlobalScore)
|
||||
|
||||
# converting the report using pylint_json2html (/!\ internal API, but as their is no leading '_' ...)
|
||||
with open(cls.get_result_dir() / "report.html", "w+", encoding="utf-8") as Outfile:
|
||||
raw_data = json.loads(JsonContent)
|
||||
report = pylint_json2html.Report(raw_data)
|
||||
Outfile.write(report.render())
|
||||
|
||||
print("Done")
|
||||
@@ -1,60 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from mypy import api
|
||||
|
||||
from .helper_base import helper_withresults_base
|
||||
|
||||
|
||||
class types_check(helper_withresults_base):
|
||||
JUnitReportName = "junit.xml"
|
||||
|
||||
@classmethod
|
||||
def do_job(cls):
|
||||
print("checking code typing ...")
|
||||
result = api.run(
|
||||
[ # project path
|
||||
"-p",
|
||||
"src." + cls.pyproject["project"]["name"],
|
||||
# analysis configuration
|
||||
# "--show-traceback",
|
||||
"--explicit-package-bases",
|
||||
# "--strict-equality",
|
||||
# "--check-untyped-defs",
|
||||
# reports generation
|
||||
"--cobertura-xml-report",
|
||||
str(cls.get_result_dir()),
|
||||
"--html-report",
|
||||
str(cls.get_result_dir()),
|
||||
"--txt-report",
|
||||
str(cls.get_result_dir()),
|
||||
"--xml-report",
|
||||
str(cls.get_result_dir()),
|
||||
"--junit-xml",
|
||||
str(cls.get_result_dir()) + "/" + cls.JUnitReportName,
|
||||
]
|
||||
)
|
||||
|
||||
if result[0]:
|
||||
print("\nType checking report:\n")
|
||||
print(result[0]) # stdout
|
||||
# converting the report using pylint_json2html (/!\ internal API, but as their is no leading '_' ...)
|
||||
with open(cls.get_result_dir() / "raw_eport.txt", "w+", encoding="utf-8") as Outfile:
|
||||
Outfile.write(result[0])
|
||||
|
||||
if result[1]:
|
||||
print("\nError report:\n")
|
||||
print(result[1]) # stderr
|
||||
|
||||
print("\nExit status:", result[2])
|
||||
print("Done")
|
||||
@@ -1,81 +0,0 @@
|
||||
# pyChaChaDummyProject (c) by chacha
|
||||
#
|
||||
# pyChaChaDummyProject is licensed under a
|
||||
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
|
||||
#
|
||||
# You should have received a copy of the license along with this
|
||||
# work. If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
|
||||
|
||||
from __future__ import annotations
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from pathlib import Path
|
||||
import os
|
||||
import datetime
|
||||
|
||||
import unittest
|
||||
import xmlrunner
|
||||
from junitparser import JUnitXml
|
||||
from junit2htmlreport import parser as junit2html_parser
|
||||
|
||||
from .helper_base import helper_withresults_base
|
||||
|
||||
|
||||
class unit_test(helper_withresults_base):
|
||||
enable_coverage_check: bool = False
|
||||
enable_xml_export: bool = True
|
||||
enable_full_xml_export: bool = True
|
||||
FullReportName: str = "full_report"
|
||||
CoverageReportName: str = "test_coverage"
|
||||
|
||||
@classmethod
|
||||
def do_job(cls):
|
||||
if cls.enable_coverage_check == True:
|
||||
import coverage
|
||||
|
||||
# preparing unittest framework
|
||||
test_loader = unittest.TestLoader()
|
||||
|
||||
if cls.enable_coverage_check == True:
|
||||
# we start coverage now because module files discovery is part of the coverage measurement
|
||||
CoverageReportPath = Path(str(cls.get_result_dir()) + "_coverage")
|
||||
cls._reset_dir(CoverageReportPath)
|
||||
cov = coverage.Coverage(cover_pylib=False, branch=True, source_pkgs=["src." + cls.pyproject["project"]["name"]])
|
||||
cov.start()
|
||||
|
||||
package_tests = test_loader.discover(
|
||||
start_dir=str(cls.project_rootdir_path / "test"), top_level_dir=str(cls.project_rootdir_path / "test")
|
||||
)
|
||||
if cls.enable_xml_export:
|
||||
testRunner = xmlrunner.XMLTestRunner(output=str(str(cls.get_result_dir())))
|
||||
else:
|
||||
testRunner = unittest.TextTestRunner()
|
||||
|
||||
# running the test
|
||||
testRunner.run(package_tests)
|
||||
|
||||
print("Test Finished")
|
||||
if cls.enable_coverage_check == True:
|
||||
cov.stop()
|
||||
cov.save()
|
||||
cov.html_report(directory=str(CoverageReportPath))
|
||||
cov.xml_report(outfile=(CoverageReportPath / f"{cls.CoverageReportName}.xml"))
|
||||
|
||||
# computing results (Only if xml available)
|
||||
if cls.enable_full_xml_export == True:
|
||||
print("Full reports generation...")
|
||||
FullReportPath = Path(str(cls.get_result_dir()) + "_full")
|
||||
cls._reset_dir(FullReportPath)
|
||||
|
||||
FullJUnitReport = JUnitXml()
|
||||
for fname in [fname for fname in os.listdir(cls.get_result_dir()) if fname.endswith(".xml")]:
|
||||
FullJUnitReport += JUnitXml.fromfile(str(cls.get_result_dir() / fname))
|
||||
|
||||
current_datetime = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
|
||||
full_report_base_name = f'{cls.pyproject["project"]["name"]}-{cls.FullReportName}-{current_datetime}'
|
||||
FullJUnitReport.write(str(FullReportPath / f"{full_report_base_name}.xml"))
|
||||
report = junit2html_parser.Junit(FullReportPath / f"{full_report_base_name}.xml")
|
||||
html = report.html()
|
||||
with open(FullReportPath / f"{full_report_base_name}.html", "wb") as outfile:
|
||||
outfile.write(html.encode("utf-8"))
|
||||
print("Done")
|
||||
5
helpers_proxy/__main__.py
Normal file
5
helpers_proxy/__main__.py
Normal file
@@ -0,0 +1,5 @@
|
||||
from chacha_cicd_helper.__main__ import fct_main
|
||||
import sys
|
||||
|
||||
if __name__ == "__main__":
|
||||
fct_main(sys.argv[1:])
|
||||
Reference in New Issue
Block a user