multimetric 2.2.1__py3-none-any.whl

multimetric/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+__all__ = ["cls"]

multimetric/__main__.py

@@ -0,0 +1,215 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+
+import argparse
+import json
+import logging
+import multiprocessing as mp
+import os
+import sys
+import textwrap
+
+import chardet
+from pygments import lexers
+
+from multimetric.cls.importer.filtered import FilteredImporter
+from multimetric.cls.importer.pick import importer_pick
+from multimetric.cls.modules import get_additional_parser_args
+from multimetric.cls.modules import get_modules_calculated
+from multimetric.cls.modules import get_modules_metrics
+from multimetric.cls.modules import get_modules_stats
+
+
+def ArgParser():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter,
+        prog="multimetric", description='Calculate code metrics in various languages',
+        epilog=textwrap.dedent("""
+        Currently you could import files of the following types for --warn_* or --coverage
+
+        Following information can be read
+
+            <file> = full path to file
+            <severity> = severity [error, warning, info]
+            <content> = optional string
+
+            Note: you could also add a single line, then <content>
+                has to be a number reflecting to total number of findings
+
+        File formats
+
+        csv: CSV file of following line format
+             <file>,<severity>,[<content>]
+
+        json: JSON file
+             <file>: {
+                 ["content": <content>,]
+                 "severity": <severity>
+             }
+        """))
+    parser.add_argument(
+        "--warn_compiler",
+        default=None,
+        help="File(s) holding information about compiler warnings")
+    parser.add_argument(
+        "--warn_duplication",
+        default=None,
+        help="File(s) holding information about code duplications")
+    parser.add_argument(
+        "--warn_functional",
+        default=None,
+        help="File(s) holding information about static code analysis findings")
+    parser.add_argument(
+        "--warn_standard",
+        default=None,
+        help="File(s) holding information about language standard violations")
+    parser.add_argument(
+        "--warn_security",
+        default=None,
+        help="File(s) File(s) holding information about found security issue")
+    parser.add_argument(
+        "--coverage",
+        default=None,
+        help="File(s) with compiler warningsFile(s) holding information about testing coverage")
+    parser.add_argument(
+        "--dump",
+        default=False,
+        action="store_true",
+        help="Just dump the token tree")
+    parser.add_argument(
+        "--verbose",
+        default=False,
+        action="store_true",
+        help="Verbose logging output")
+    parser.add_argument(
+        "--jobs",
+        type=int,
+        default=mp.cpu_count(),
+        help="Run x jobs in parallel")
+    get_additional_parser_args(parser)
+    parser.add_argument("files", nargs='+', help="Files to parse")
+    return parser
+
+
+def parse_args(*args):
+    RUNARGS = ArgParser().parse_args(*args)
+    # Turn all paths to abs-paths right here
+    RUNARGS.files = [os.path.abspath(x) for x in RUNARGS.files]
+
+    # Setup logging
+    stdout_log = logging.getLogger('stdout')
+    stdout_log.setLevel(logging.DEBUG if RUNARGS.verbose else logging.INFO)
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.DEBUG if RUNARGS.verbose else logging.INFO)
+    formatter = logging.Formatter('%(message)s')
+    handler.setFormatter(formatter)
+    stdout_log.addHandler(handler)
+
+    stderr_log = logging.getLogger('stderr')
+    stderr_log.setLevel(logging.DEBUG if RUNARGS.verbose else logging.INFO)
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(logging.DEBUG if RUNARGS.verbose else logging.INFO)
+    formatter = logging.Formatter('%(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    stderr_log.addHandler(handler)
+
+    return RUNARGS
+
+
+def file_process(_file, _args, _importer):
+    res = {}
+    store = {}
+    try:
+        _lexer = lexers.get_lexer_for_filename(_file)
+    except ValueError:  # pragma: no cover - bug in pytest-cov
+        logging.getLogger('stderr').error(
+            f'The file {_file} could not be identified automatically. Skipping this file.')  # pragma: no cover - bug in pytest-cov
+        return ({}, _file, 'lexer.error', [], {})  # pragma: no cover - bug in pytest-cov
+    try:
+        with open(_file, "rb") as i:
+            _cnt = i.read()
+            _enc = chardet.detect(_cnt)
+            _cnt = _cnt.decode(_enc["encoding"]).encode("utf-8")
+        _localImporter = {k: FilteredImporter(
+            v, _file) for k, v in _importer.items()}
+        tokens = list(_lexer.get_tokens(_cnt))
+        if _args.dump:  # pragma: no cover
+            for x in tokens:  # pragma: no cover
+                logging.getLogger('stdout').info(f"{_file}: {x[0]} -> {repr(x[1])}")  # pragma: no cover
+        else:
+            _localMetrics = get_modules_metrics(_args, **_localImporter)
+            _localCalc = get_modules_calculated(_args, **_localImporter)
+            for x in _localMetrics:
+                x.parse_tokens(_lexer.name, tokens)
+                res.update(x.get_results())
+                store.update(x.get_internal_store())
+            for x in _localCalc:
+                res.update(x.get_results(res))
+                store.update(x.get_internal_store())
+    except Exception as e:  # pragma: no cover
+        logging.getLogger('stderr').exception(e)  # pragma: no cover
+        tokens = []  # pragma: no cover
+    return (res, _file, _lexer.name, tokens, store)
+
+
+def run(_args):
+    _result = {"files": {}, "overall": {}}
+
+    # Get importer
+    _importer = {}
+    _importer["import_compiler"] = importer_pick(_args, _args.warn_compiler)
+    _importer["import_coverage"] = importer_pick(_args, _args.coverage)
+    _importer["import_duplication"] = importer_pick(
+        _args, _args.warn_duplication)
+    _importer["import_functional"] = importer_pick(
+        _args, _args.warn_functional)
+    _importer["import_security"] = importer_pick(_args, _args.warn_standard)
+    _importer["import_standard"] = importer_pick(_args, _args.warn_security)
+    # sanity check
+    _importer = {k: v for k, v in _importer.items() if v}
+
+    # instance metric modules
+    _overallMetrics = get_modules_metrics(_args, **_importer)
+    _overallCalc = get_modules_calculated(_args, **_importer)
+
+    with mp.Pool(processes=_args.jobs) as pool:
+        results = [pool.apply(file_process, args=(
+            f, _args, _importer)) for f in _args.files]
+
+    for x in results:
+        _result["files"][x[1]] = x[0]
+
+    for y in _overallMetrics:
+        _result["overall"].update(
+            y.get_results_global([x[4] for x in results]))
+    for y in _overallCalc:
+        _result["overall"].update(y.get_results(_result["overall"]))
+    for m in get_modules_stats(_args, **_importer):
+        _result = m.get_results(_result, "files", "overall")
+
+    def round_float(item):
+        if isinstance(item, dict):
+            for k, v in item.items():
+                item[k] = round_float(v)
+        elif isinstance(item, list):
+            for index, value in enumerate(item):
+                item[index] = round_float(value)
+        elif isinstance(item, float):
+            item = round(item, 3)
+        return item
+
+    return round_float(_result)
+
+
+def main():  # pragma: no cover
+    _args = parse_args()  # pragma: no cover
+    _result = run(_args)  # pragma: no cover
+    if not _args.dump:  # pragma: no cover
+        # Output
+        logging.getLogger('stdout').info(json.dumps(_result, indent=2, sort_keys=True))  # pragma: no cover
+
+
+if __name__ == '__main__':
+    main()  # pragma: no cover

multimetric/cls/base.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+class MetricBase():
+    def __init__(self, args, **kwargs):
+        self._metrics = {"lang": []}
+        self._internalstore = {}
+
+    def parse_tokens(self, language, tokens):
+        if language not in self._metrics["lang"]:  # pragma: no cover
+            self._metrics["lang"].append(language)
+
+    def get_results(self):
+        return self._metrics
+
+    def get_internal_store(self):
+        return {self.__class__.__name__: self._internalstore}
+
+    def _get_all_matching_store_objects(self, store):
+        res = []
+        for item in store:
+            if self.__class__.__name__ in item:
+                res.append(item[self.__class__.__name__])
+        return res
+
+    def get_results_global(self, value_stores):
+        return {}  # pragma: no cover

multimetric/cls/base_calc.py

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+class MetricBaseCalc():
+
+    def __init__(self, args, **kwargs):
+        self._metrics = {}
+        self._internalstore = {}
+
+    def get_results(self, metrics):
+        """
+        This alters the originally passed metrics by calculated ones
+        """
+        return metrics
+
+    def get_internal_store(self):
+        return self._internalstore

multimetric/cls/base_stats.py

@@ -0,0 +1,12 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+class MetricBaseStats():
+
+    def __init__(self, args, **kwargs):
+        self._metrics = {}
+
+    def get_results(self, metrics, files="files", overall="overall"):
+        """
+        This alters the originally passed metrics by calculated ones
+        """
+        return metrics

multimetric/cls/calc/halstead.py

@@ -0,0 +1,308 @@
+# SPDX-FileCopyrightText: 2023 Konrad Weihmann
+# SPDX-License-Identifier: Zlib
+
+import math
+
+from multimetric.cls.base_calc import MetricBaseCalc
+from multimetric.cls.metric.operands import MetricBaseOperands
+from multimetric.cls.metric.operators import MetricBaseOperator
+
+
+class MetricBaseCalcHalstead(MetricBaseCalc):
+    """A class for calculating Halstead metrics.
+
+    This class inherits from MetricBaseCalc.
+
+    Attributes
+    ----------
+    METRIC_HALSTEAD_VOLUME : str
+        The name of the Halstead volume metric.
+    METRIC_HALSTEAD_EFFORT : str
+        The name of the Halstead effort metric.
+    METRIC_HALSTEAD_DIFFICULTY : str
+        The name of the Halstead difficulty metric.
+    METRIC_HALSTEAD_BUGS : str
+        The name of the Halstead bugprop metric.
+    METRIC_HALSTEAD_TIMEREQ : str
+        The name of the Halstead timerequired metric.
+
+    Methods
+    -------
+    _bugpred_old(obj)
+        Calculate the bug prediction using the old method.
+    _bugpred_new(obj)
+        Calculate the bug prediction using the new method.
+    _getNs(metrics)
+        Calculate the values of N1, N2, n1, n2.
+    _getVocabulary(metrics)
+        Calculate the vocabulary of the program.
+    _getProgLength(metrics)
+        Calculate the program length.
+    _getVolume(metrics)
+        Calculate the Halstead volume.
+    _getDifficulty(metrics)
+        Calculate the Halstead difficulty.
+    _getEffort(metrics)
+        Calculate the Halstead effort.
+    _getTime(metrics)
+        Calculate the time required.
+    _getBug(metrics)
+        Calculate the bugprop.
+    get_results(metrics)
+        Calculate all the Halstead metrics and return the results.
+
+    """
+
+    METRIC_HALSTEAD_VOLUME = "halstead_volume"
+    METRIC_HALSTEAD_EFFORT = "halstead_effort"
+    METRIC_HALSTEAD_DIFFICULTY = "halstead_difficulty"
+    METRIC_HALSTEAD_BUGS = "halstead_bugprop"
+    METRIC_HALSTEAD_TIMEREQ = "halstead_timerequired"
+
+    @staticmethod
+    def _bugpred_old(obj):
+        """Calculate the bug prediction using the old method.
+
+        Parameters
+        ----------
+        obj : MetricBaseCalcHalstead
+            The MetricBaseCalcHalstead object.
+
+        Returns
+        -------
+        float
+            The bug prediction using the old method.
+
+        """
+        return (obj._effort * (2.0 / 3.0)) / 3000.0
+
+    @staticmethod
+    def _bugpred_new(obj):
+        """Calculate the bug prediction using the new method.
+
+        Parameters
+        ----------
+        obj : MetricBaseCalcHalstead
+            The MetricBaseCalcHalstead object.
+
+        Returns
+        -------
+        float
+            The bug prediction using the new method.
+
+        """
+        return obj._volume / 3000.0
+
+    BUGPRED_DEFAULT = "new"
+    BUGPRED_METHOD = {
+        "old": _bugpred_old,
+        "new": _bugpred_new,
+    }
+
+    def __init__(self, args, **kwargs):
+        """Initialize the MetricBaseCalcHalstead object.
+
+        Parameters
+        ----------
+        args : argparse.Namespace
+            The command line arguments.
+        **kwargs
+            Additional keyword arguments.
+
+        """
+        super().__init__(args, **kwargs)
+        self.__bugPredicMethod = args.halstead_bug_predict_method
+
+    def _getNs(self, metrics):
+        """Calculate the values of N1, N2, n1, n2.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Notes
+        -----
+        - N1 is the total number of operators
+        - N2 is the total number of operands
+        - n1 is the number of distinct operators
+        - n2 is the number of distinct operands
+        """
+        self._N2 = float(metrics[MetricBaseOperands.METRIC_OPERANDS_SUM])
+        self._N1 = float(metrics[MetricBaseOperator.METRIC_OPERATORS_SUM])
+        self._n2 = float(metrics[MetricBaseOperands.METRIC_OPERANDS_UNIQUE])
+        self._n1 = float(metrics[MetricBaseOperator.METRIC_OPERATORS_UNIQUE])
+        # to avoid any Divbyzero bugs set the minimum to 1
+        self._n1 = max(self._n1, 1)
+        self._n2 = max(self._n2, 1)
+        self._N1 = max(self._N1, 1)
+        self._N2 = max(self._N2, 1)
+
+    def _getVocabulary(self, metrics):
+        """Calculate the vocabulary of the program.
+
+        Halstead vocabulary (n) is defined as the sum of distinct
+        operators and operands. (n1 + n2)
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The vocabulary of the program.
+
+        """
+        self._getNs(metrics)
+        self._vocabulary = self._n1 + self._n2
+        # to avoid a log(0) the minimum of vocabulary is 1
+        self._vocabulary = max(1, self._vocabulary)
+        return self._vocabulary
+
+    def _getProgLength(self, metrics):
+        """Calculate the program length.
+
+        Halstead program length (N) is defined as the sum of total
+        operators and operands. (N1 + N2).
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The program length.
+
+        """
+        self._getNs(metrics)
+        self._length = self._N1 + self._N2
+        return self._length
+
+    def _getVolume(self, metrics):
+        """Calculate the Halstead volume.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The Halstead volume.
+
+        """
+        self._getVocabulary(metrics)
+        self._getProgLength(metrics)
+        self._volume = self._length * math.log2(self._vocabulary)
+        # to avoid a log(0) the minimum of volume is 1
+        self._volume = max(1, self._volume)
+        return self._volume
+
+    def _getDifficulty(self, metrics):
+        """Calculate the Halstead difficulty.
+
+        The difficulty measure is related to the difficulty of the program
+        to write or understand, e.g. when doing code review.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The Halstead difficulty.
+
+        """
+        self._getNs(metrics)
+        self._difficulty = (self._n1 / 2.0) * (self._N2 / self._n2)
+        return self._difficulty
+
+    def _getEffort(self, metrics):
+        """Calculate the Halstead effort.
+
+        The effort measure translates into actual coding time.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The Halstead effort.
+
+        """
+        self._getVolume(metrics)
+        self._getDifficulty(metrics)
+        self._effort = self._volume * self._difficulty
+        return self._effort
+
+    def _getTime(self, metrics):
+        """Calculate the estimated time required to write program.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The time required to write the program, in seconds.
+
+        """
+        self._getEffort(metrics)
+        self._timeRequired = self._effort / 18.0
+        return self._timeRequired
+
+    def _getBug(self, metrics):
+        """Calculate the estimate for the number of errors in the implementation.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        float
+            The number of delivered bugs.
+        """
+        self._getEffort(metrics)
+        self._bug = MetricBaseCalcHalstead.BUGPRED_METHOD[self.__bugPredicMethod](self)
+        return self._bug
+
+    def get_results(self, metrics):
+        """Calculate all the Halstead metrics and return the results.
+
+        Parameters
+        ----------
+        metrics : dict
+            The metrics dictionary.
+
+        Returns
+        -------
+        dict
+            The metrics dictionary with the Halstead metrics added.
+
+        """
+        metrics[MetricBaseCalcHalstead.METRIC_HALSTEAD_VOLUME] = self._getVolume(
+            metrics,
+        )
+        metrics[
+            MetricBaseCalcHalstead.METRIC_HALSTEAD_DIFFICULTY
+        ] = self._getDifficulty(metrics)
+        metrics[MetricBaseCalcHalstead.METRIC_HALSTEAD_EFFORT] = self._getEffort(
+            metrics,
+        )
+        metrics[MetricBaseCalcHalstead.METRIC_HALSTEAD_TIMEREQ] = self._getTime(metrics)
+        metrics[MetricBaseCalcHalstead.METRIC_HALSTEAD_BUGS] = self._getBug(metrics)
+        return super().get_results(metrics)