updates

.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>gitversionhelper</name>
+	<name>pygitversionhelper</name>
 	<comment></comment>
 	<projects>
 	</projects>

Jenkinsfile

@@ -137,7 +137,7 @@ pipeline {
                 
                 script {
                     if(_PROJECT_NAME!="pygitversionhelper") {
-                        sh(". ~/TOOLS_ENV/bin/activate && pip install git+https://chacha.ddns.net/gitea/chacha/pygitversionhelper.git@master")
+                        sh(". ~/TOOLS_ENV/bin/activate && pip install pygitversionhelper")
                     }
                     else
                     {   
@@ -561,7 +561,7 @@ pipeline {
                            withCredentials([usernamePassword( credentialsId: _PypiCredentials, passwordVariable: 'PYPI_PASSWORD', usernameVariable: 'PYPI_USERNAME')]) {
                             sh(script:   """#!/bin/sh -
                                             |. ~/TOOLS_ENV/bin/activate
-                                            |exec twine upload -r ${PY_PROJECT_NAME} dist/* -u ${PYPI_USERNAME} -p ${PYPI_PASSWORD} --non-interactive --disable-progress-bar 
+                                            |exec twine upload -u ${PYPI_USERNAME} -p ${PYPI_PASSWORD} --non-interactive --disable-progress-bar dist/*
                                          """.stripMargin())
 						    }
 					    }

helpers/__init__.py

@@ -4,4 +4,4 @@
 # 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/>.
+# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.

helpers/__main__.py

@@ -16,132 +16,89 @@ import os
 import logging
 import sys
 
-if __package__ == "helpers":
+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 .changelog_gen import changelog_gen
-else:
+    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 .changelog_gen import  changelog_gen
+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.changelog_gen import changelog_gen
-
+    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.changelog_gen import  changelog_gen
+    
 logging.getLogger().setLevel(logging.INFO)
 
 if __name__ == "__main__":
-    project_rootdir_path = Path(__file__).parent.parent.absolute()
+    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 = 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(
-        "-clg",
-        "--changelog-gen",
-        dest="changeloggen",
-        action="store_true",
-        help="enable changelog generation",
-    )
-
+    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('-clg', '--changelog-gen',  dest='changeloggen',    action='store_true',    help='enable changelog generation')   
+    
     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.changeloggen   = True
-
+    #args.typecheck      = True
+    #args.qualitycheck   = True
+    #args.unittest       = True
+    #args.coveragecheck  = True
+    #args.docgen         = True
+    #args.docgenpdf      = True
+    #args.changeloggen   = True
+    
     helpers = []
-    if args.typecheck == True:
+    if  args.typecheck == True:
         helpers.append(types_check)
-
-    if args.unittest == True:
+        
+    if  args.unittest == True:
         helpers.append(unit_test)
-
-    if args.coveragecheck == True:
+    
+    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:
+    
+    if  args.qualitycheck == True:
         helpers.append(quality_check)
-
-    if args.docgen == True:
+        
+    if  args.docgen == True:
         helpers.append(doc_gen)
-
-    if args.docgenpdf == True:
+    
+    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.changeloggen == True:
+        
+    if  args.changeloggen == True:
         helpers.append(changelog_gen)
-
+    
     for helper in helpers:
-        helper.set_context(project_rootdir_path, pyproject)
+        helper.set_context(project_rootdir_path,pyproject)
         helper.reset_result_dir()
         helper.do_job()
+        

helpers/changelog_gen.py

@@ -9,15 +9,16 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-# from pathlib import Path
-# import os
-# import datetime
+#from pathlib import Path
+#import os
+#import datetime
 
 
 from .helper_base import helper_base
 
 
-class changelog_gen(helper_base):
-    @classmethod
-    def do_job(cls):
-        pass
+class changelog_gen(helper_base): 
+    
+    @classmethod  
+    def do_job(cls): 
+        pass

helpers/doc_gen.py

@@ -17,7 +17,6 @@ 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:
@@ -25,44 +24,35 @@ except ImportError:
 
 from .helper_base import helper_withresults_base
 
-
-class doc_gen(helper_withresults_base):
+class doc_gen(helper_withresults_base): 
     enable_gen_pdf: bool = False
-
-    @classmethod
-    def do_job(cls):
+    
+    @classmethod  
+    def do_job(cls): 
         print(cls.project_rootdir_path)
         print()
-
+        
         # create doc root dir
-        doc_path = cls.project_rootdir_path / "docs"
+        doc_path = cls.project_rootdir_path/"docs"
         cls._reset_dir(doc_path)
-
-        site_path = cls.get_result_dir() / "site"
+        
+        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")
-        )
-
+        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))
-
+        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)
-
+        
         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"
-            )
+            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)
@@ -71,60 +61,43 @@ class doc_gen(helper_withresults_base):
                 parts = parts[:-1]
             elif parts[-1] == "__main__":
                 continue
-
+            
             cls._reset_dir(os.path.dirname(full_doc_path))
             with open(full_doc_path, "w+") as fd:
-                identifier = "src." + ".".join(parts)
+                identifier = "src."+".".join(parts)
                 print("::: " + identifier, file=fd)
-
-        cmdopts = [
-            f"{sys.executable}",
-            "-m",
-            "mkdocs",
-            "-v",
-            "build",
-            "--site-dir",
-            str(site_path),
-            "--clean",
-        ]
-
+  
+            
+        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
+        # => reason is mkdocs seems to try loading the plugin even if we disable it, so we need to 
         # manually process the configuration file.
-        mkdocsCfg = None
-        with open(cls.project_rootdir_path / "mkdocs.yml", "r") as mkdocsCfgFile:
+        mkdocsCfg=None
+        with open(cls.project_rootdir_path / "mkdocs.yml",'r') as mkdocsCfgFile:
             mkdocsCfg = yaml.load(mkdocsCfgFile, Loader=yaml.SafeLoader)
-
-            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,
-                            "media_type": "print",
-                            "headless_chrome_path": "chromium",
-                            "exclude_pages": ["LICENSE"],
-                            "output_path": str(site_path / "pdf" / "manual.pdf"),
-                        }
-                    }
-                )
+            
+            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,
+                                                    'media_type':       'print',
+                                                    'exclude_pages':    ['LICENSE'],
+                                                    'output_path':      str(site_path / 'pdf' / 'manual.pdf')  
+                                            }})
             else:
-                for subelem in mkdocsCfg["plugins"]:
-                    if isinstance(subelem, dict):
-                        if "with-pdf" in subelem.keys():
-                            mkdocsCfg["plugins"].remove(subelem)
-                            break
-
-        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
-                )
-            )
-
-        res = cls.run_cmd(cmdopts)
+                for subelem in mkdocsCfg['plugins']:
+                    if isinstance(subelem,dict) :
+                        if 'with-pdf' in subelem.keys():  
+                            mkdocsCfg['plugins'].remove(subelem)
+                            break          
+            
+        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))
+            
+        
+        res=cls.run_cmd(cmdopts)
         print(res.decode())
-        print(" !! done")
+        print(' !! done')
+        

helpers/helper_base.py

@@ -9,76 +9,64 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from abc import ABC, abstractmethod
+from abc import ABC,abstractmethod
 import os
 from pathlib import Path
 import subprocess
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
-    from typing import Union
-
+    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
+    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 _reset_dir(dirpath: Path):
+ 
+    @staticmethod  
+    def _reset_dir(dirpath:Path):  
         dirpath = Path(dirpath)
         if not os.path.exists(dirpath):
             os.makedirs(dirpath)
-        [f.unlink() for f in Path(dirpath).glob("*") if f.is_file()]
-
-    @classmethod
+        [f.unlink() for f in Path(dirpath).glob("*") if f.is_file()] 
+    
+    @classmethod    
     def reset_result_dir(cls):
         result_dir = cls.get_result_dir()
         if result_dir != None:
             cls._reset_dir(result_dir)
-
-    @classmethod
+    
+    @classmethod 
     @abstractmethod
-    def do_job(cls):
+    def do_job(cls):  
         raise NotImplementedError()
 
-    @classmethod
+    @classmethod  
     def run_cmd_(cls, cmdarray):
-        process = subprocess.run(
-            cmdarray,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            shell=True,
-            check=True,
-        )
+        process = subprocess.run(cmdarray, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, check=True)
         return process.stdout
-
-    @classmethod
+    
+    @classmethod  
     def run_cmd(cls, cmdarray):
         p = subprocess.run(cmdarray, capture_output=True)
         print(p.stdout)
         print(p.stderr)
         return p.stdout
-
-
+    
 class helper_withresults_base(helper_base):
-    helper_results_dir: Union[Path, None] = None
-
-    @classmethod
+    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
-        )
+        if cls.helper_results_dir==None:
+            cls.helper_results_dir=cls.__name__
+        return Path(__file__).parent.parent.absolute() / "helpers-results" / cls.helper_results_dir

helpers/quality_check.py

@@ -25,289 +25,197 @@ import pylint_json2html
 
 from .helper_base import helper_withresults_base
 
-
 class PyLintMetricNotFound(Warning):
     pass
 
-
-class quality_check(helper_withresults_base):
-    PylintMessageList = dict()
-
-    @classmethod
+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"]
-        ).splitlines():
-            if res := re.search(regex, line.decode()):
-                Messagelist[res.group(1)] = res.group(2)
+        Messagelist=dict()
+        regex = r"^:([a-zA-Z-]+) \(([^\)]+)\)"  
+        for line in cls.run_cmd([sys.executable,"-m","pylint","--list-msgs"]).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):
+    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):
+    @classmethod  
+    def do_job(cls):  
         print("checking code quality ...")
         cls.GetPylintMessageList()
-
-        RES_all = dict()
+        
+        RES_all=dict()
         with StringIO() as StdOutput:
-            JsonContent = ""
+            JsonContent=""
             with redirect_stdout(StdOutput):
-                pylint_Run(
-                    [
-                        "--output-format=json,parseable",
-                        "--disable=invalid-name",
-                        "--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:
+                pylint_Run(['--output-format=json,parseable',
+                            '--disable=invalid-name',
+                            '--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
-
+                    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:
+                for line in StdOutput.getvalue().split('\n'):     
+                    print(line)                   
+                    if      ScanState == TScanState.TEXT_REPORT:
                         # ignoring this part, we need json
-                        if line == "[":
-                            JsonContent += line
+                        if line=='[':
+                            JsonContent+=line
                             ScanState = TScanState.JSON_REPORT
-                        elif line == "[]":
-                            JsonContent += line
+                        elif line=='[]':
+                            JsonContent+=line
                             ScanState = TScanState.OTHER_REPORT_START
-
-                    elif ScanState == TScanState.JSON_REPORT:
-                        JsonContent += line
-                        if line == "]":
+                            
+                    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))
+                            
+                    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    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:
+                            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"]
-                            )
+                            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:
+                            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:
+                            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:
+                            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"])
+                                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:
+                
+        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...
+  
+        # 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())
+        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())
+        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())
+        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())
+        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())
+        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:
+        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)
+            report=pylint_json2html.Report( raw_data)
             Outfile.write(report.render())
-
+                
         print("Done")

helpers/types_check.py

@@ -16,46 +16,36 @@ from mypy import api
 from .helper_base import helper_withresults_base
 
 
-class types_check(helper_withresults_base):
+class types_check(helper_withresults_base): 
     JUnitReportName = "junit.xml"
-
-    @classmethod
-    def do_job(cls):
+    
+    @classmethod  
+    def do_job(cls):  
         print("checking code typing ...")
-        result = api.run(
-            [  # project path
-                "-m",
-                "src." + str(cls.pyproject["project"]["name"]),
-                # analysis configuration
-                "--ignore-missing-imports",
-                "--strict-equality",
-                # reports generation
-                "--cobertura-xml-report",
-                str(cls.get_result_dir()),
-                "--html-report",
-                str(cls.get_result_dir()),
-                "--linecount-report",
-                str(cls.get_result_dir()),
-                "--linecoverage-report",
-                str(cls.get_result_dir()),
-                "--lineprecision-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,
-            ]
-        )
-
+        result = api.run([      # project path
+                                "-m",
+                                "src." + str(cls.pyproject['project']['name']),
+                                # analysis configuration
+                                "--ignore-missing-imports",
+                                "--strict-equality",
+                                # reports generation
+                                "--cobertura-xml-report",   str(cls.get_result_dir()),
+                                "--html-report",            str(cls.get_result_dir()),
+                                "--linecount-report",       str(cls.get_result_dir()),
+                                "--linecoverage-report",    str(cls.get_result_dir()),
+                                "--lineprecision-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('\nType checking report:\n')
             print(result[0])  # stdout
-
+        
         if result[1]:
-            print("\nError report:\n")
+            print('\nError report:\n')
             print(result[1])  # stderr
-
-        print("\nExit status:", result[2])
-        print("Done")
+        
+        print('\nExit status:', result[2])
+        print("Done")

helpers/unit_test.py

@@ -21,41 +21,34 @@ 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
+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:
+    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")
+            #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 = 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"),
-        )
+        
+        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)
 
@@ -64,33 +57,23 @@ class unit_test(helper_withresults_base):
             cov.stop()
             cov.save()
             cov.html_report(directory=str(CoverageReportPath))
-            cov.xml_report(
-                outfile=(CoverageReportPath / f"{cls.CoverageReportName}.xml")
-            )
-
+            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")
+            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))
-
+            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"
-            )
+            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")
+            with open(FullReportPath/ f'{full_report_base_name}.html', "wb") as outfile:
+                outfile.write(html.encode('utf-8'))
+            print("Done")

mkdocs.yml

@@ -1,3 +1,11 @@
+# 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/>.
+
 docs_dir: docs
 site_name: pygitversionhelper
 site_url: 'https://chacha.ddns.net/mkdocs-web/chacha/pygitversionhelper/latest/'