msgram 3.2.0__tar.gz → 3.2.2__tar.gz

{msgram-3.2.0 → msgram-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msgram
-Version: 3.2.0
+Version: 3.2.2
 Summary: The msgram CLI is a command-line interface to use MeasureSoftGram software
 Author-email: MeasureSoftGram <measuresoftgram@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -684,7 +684,7 @@ Requires-Dist: setuptools~=72.1.0
 Requires-Dist: python-dotenv
 Requires-Dist: rich
 Requires-Dist: validators~=0.33.0
-Requires-Dist: msgram-core~=1.4.6
+Requires-Dist: msgram-core~=1.4.9
 Requires-Dist: msgram-parser~=1.2.1
 Requires-Dist: anytree
 Provides-Extra: dev

{msgram-3.2.0 → msgram-3.2.2}/msgram.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: msgram
-Version: 3.2.0
+Version: 3.2.2
 Summary: The msgram CLI is a command-line interface to use MeasureSoftGram software
 Author-email: MeasureSoftGram <measuresoftgram@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -684,7 +684,7 @@ Requires-Dist: setuptools~=72.1.0
 Requires-Dist: python-dotenv
 Requires-Dist: rich
 Requires-Dist: validators~=0.33.0
-Requires-Dist: msgram-core~=1.4.6
+Requires-Dist: msgram-core~=1.4.9
 Requires-Dist: msgram-parser~=1.2.1
 Requires-Dist: anytree
 Provides-Extra: dev

{msgram-3.2.0 → msgram-3.2.2}/msgram.egg-info/requires.txt

@@ -8,7 +8,7 @@ setuptools~=72.1.0
 python-dotenv
 rich
 validators~=0.33.0
-msgram-core~=1.4.6
+msgram-core~=1.4.9
 msgram-parser~=1.2.1
 anytree
 

{msgram-3.2.0 → msgram-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "msgram"
-version = "3.2.0"
+version = "3.2.2"
 description = "The msgram CLI is a command-line interface to use MeasureSoftGram software"
 readme = "README.md"
 authors = [
@@ -32,7 +32,7 @@ dependencies = [
         "python-dotenv",
         "rich",
         "validators~=0.33.0",
-        "msgram-core~=1.4.6",
+        "msgram-core~=1.4.9",
         "msgram-parser~=1.2.1",
         "anytree"
     ]

msgram-3.2.2/src/cli/aggregate_metrics.py

@@ -0,0 +1,147 @@
+import os
+import json
+
+from src.cli.utils import print_error, print_info
+
+metrics = {}
+metrics["sonar"] = [
+    "tests",
+    "test_failures",
+    "test_errors",
+    "coverage",
+    "test_execution_time",
+    "functions",
+    "complexity",
+    "comment_lines_density",
+    "duplicated_lines_density",
+]
+
+metrics["github"] = [
+    "resolved_issues",
+    "total_issues",
+    "sum_ci_feedback_times",
+    "total_builds",
+]
+
+measures = {}
+measures["sonarqube"] = [
+    "passed_tests",
+    "test_builds",
+    "test_errors",
+    "test_coverage",
+    "non_complex_file_density",
+    "commented_file_density",
+    "duplication_absense",
+]
+
+measures["github"] = ["team_throughput", "ci_feedback_time"]
+
+
+def should_process_metrics(config):
+    for characteristic in config.get("characteristics", []):
+        for subcharacteristic in characteristic.get("subcharacteristics", []):
+            for measure in subcharacteristic.get("measures", []):
+                if (
+                    measure.get("key") not in measures["sonarqube"]
+                    and measure.get("key") not in measures["github"]
+                ):
+                    return False
+    return True
+
+
+def read_msgram(file_path):
+    try:
+        with open(file_path, "r") as file:
+            return json.load(file)
+    except IsADirectoryError as e:
+        print_error(f"> [red] Error: {e}")
+        return False
+    except FileNotFoundError as e:
+        print_error(f"> [red] Error: {e}")
+        return False
+
+
+def list_msgram_files(folder_path):
+    try:
+        if not os.path.isdir(folder_path):
+            raise NotADirectoryError(f"{folder_path} is not a directory.")
+
+        msgram_files = [
+            file for file in os.listdir(folder_path) if file.endswith(".msgram")
+        ]
+        return msgram_files
+
+    except NotADirectoryError as e:
+        print_error(f"> [red] Error: {e}")
+        return False
+
+
+def save_metrics(file_name, metrics):
+    directory = os.path.dirname(file_name)
+
+    os.makedirs(directory, exist_ok=True)
+
+    output_file_path = os.path.join(
+        directory, os.path.basename(file_name).replace(".msgram", ".metrics")
+    )
+    with open(output_file_path, "w") as output_file:
+        json.dump(metrics, output_file, indent=2)
+
+    print_info(f"> [blue] Metrics saved to: {output_file_path}\n")
+
+
+def process_metrics(folder_path, msgram_files):
+    processed_files = []
+
+    for file in msgram_files:
+        print_info(f"> [blue] Processing {file}")
+        metrics_dict = read_msgram(os.path.join(folder_path, file))
+
+        if not metrics_dict:
+            print_error(f"> [red] Error to read metrics in: {folder_path}\n")
+            return False
+
+        processed_files.append((file, metrics_dict))
+
+    return processed_files
+
+
+def aggregate_metrics(input_format, folder_path, config: json):
+    msgram_files = list_msgram_files(folder_path)
+
+    if not msgram_files:
+        print_error("> [red]Error: Can not read msgram files in provided directory")
+        return False
+
+    github_files = [file for file in msgram_files if file.startswith("github_")]
+    sonar_files = [file for file in msgram_files if file not in github_files]
+    file_content = {}
+
+    result = []
+
+    have_metrics = False
+
+    if should_process_metrics(config):
+        result = process_metrics(
+            folder_path, github_files if input_format == "github" else sonar_files
+        )
+
+        if not result:
+            print_error("> [red]Error: Unexpected result from process_github_metrics")
+            return False
+
+        have_metrics = True
+    else:
+        print_error("> [red]Error: Unexpected measures from should_process_metrics")
+        return False
+
+    if not have_metrics:
+        print_error(
+            f"> [red]Error: No metrics where found in the .msgram files from the type: {input_format}"
+        )
+        return False
+
+    for filename, file_content in result:
+        save_metrics(os.path.join(folder_path, filename), file_content)
+
+    return True

{msgram-3.2.0 → msgram-3.2.2}/src/cli/commands/cmd_calculate.py

@@ -34,26 +34,31 @@ def read_config_file(config_path):
         exit(1)
 
 
-def calculate_metrics(extracted_path, config):
+def calculate_metrics(input_format, extracted_path, config):
     data_calculated = []
 
     if not extracted_path.is_file():
-        if not aggregate_metrics(extracted_path, config):
+        if not aggregate_metrics(input_format, extracted_path, config):
             print_error(
                 "> [red] Failed to aggregate metrics, calculate was not performed. \n"
             )
             return data_calculated, False
 
-        for file, file_name in read_multiple_files(extracted_path, "metrics"):
+        for file, file_name in read_multiple_files(
+            extracted_path, input_format, "metrics"
+        ):
+            if file_name.startswith("github_"):
+                file_name = file_name[len("github_") :]
             result = calculate_all(file, file_name, config)
             data_calculated.append(result)
 
         return data_calculated, True
     else:
         try:
-            result = calculate_all(
-                open_json_file(extracted_path), extracted_path.name, config
-            )
+            file_name = extracted_path.name
+            if extracted_path.name.startswith("github_"):
+                file_name = file_name[len("github_") :]
+            result = calculate_all(open_json_file(extracted_path), file_name, config)
             return result, True
         except exceptions.MeasureSoftGramCLIException as e:
             print_error(f"[red]Error calculating {extracted_path}: {e}\n")
@@ -63,6 +68,7 @@ def calculate_metrics(extracted_path, config):
 def command_calculate(args):
     try:
         output_format: str = args["output_format"]
+        input_format: str = args["input_format"]
         config_path = args["config_path"]
         extracted_path = args["extracted_path"]
 
@@ -80,7 +86,7 @@ def command_calculate(args):
 
     print_info("\n> [blue] Reading extracted files:[/]")
 
-    data_calculated, success = calculate_metrics(extracted_path, config)
+    data_calculated, success = calculate_metrics(input_format, extracted_path, config)
 
     if success:
         print_info("\n[#A9A9A9]All calculations performed[/] successfully!")

{msgram-3.2.0 → msgram-3.2.2}/src/cli/commands/cmd_diff.py

@@ -17,20 +17,18 @@ from src.cli.utils import (
     print_rule,
 )
 from src.cli.exceptions import exceptions
-from src.config.settings import DEFAULT_CONFIG_PATH, DIFF_FILE_CONFIG
+from src.config.settings import DEFAULT_CONFIG_PATH
 
 logger = logging.getLogger("msgram")
 
 
 def read_config_file(config_path):
     try:
-        json = open_json_file(config_path / DIFF_FILE_CONFIG)
+        json = open_json_file(config_path)
 
         return sorted(json, key=lambda x: x["key"])
     except exceptions.MeasureSoftGramCLIException as e:
-        print_error(
-            f"[red]Error reading msgram_diff.json config file in {config_path}: {e}\n"
-        )
+        print_error(f"[red]Error reading config file in {config_path}: {e}\n")
         print_rule()
         exit(1)
 
@@ -107,8 +105,8 @@ def calculate_diff(planned, calculated):
 def command_diff(args):
     try:
         output_format: str = args["output_format"]
-        config_path = args["config_path"]
-        extracted_calculation = args["extracted_calculation"]
+        config_path = args["rp_path"]
+        extracted_calculation = args["rd_path"]
 
     except KeyError as e:
         logger.error(f"KeyError: args[{e}] - non-existent parameters")
@@ -130,6 +128,8 @@ def command_diff(args):
 
     if success:
         print_info("\n[#A9A9A9]Diff calculation performed[/] successfully!")
+    else:
+        exit(1)
 
     show_results(output_format, diff_calculated, config_path)
     print_rule()
@@ -167,7 +167,7 @@ def show_tabulate(data_calculated):
 
 
 def export_json(data_calculated: list, file_path: Path = DEFAULT_CONFIG_PATH):
-    file_path = file_path.joinpath("calc_diff_msgram.json")
+    file_path = file_path.parent.joinpath("calc_diff_msgram.json")
     with open(file_path, "w", encoding="utf-8") as write_file:
         json.dump(
             data_calculated,
@@ -178,10 +178,17 @@ def export_json(data_calculated: list, file_path: Path = DEFAULT_CONFIG_PATH):
 
 
 def export_csv(data_calculated: list, file_path: Path = Path("DEFAULT_CONFIG_PATH")):
-    file_path = file_path.joinpath("calc_diff_msgram.csv")
+    file_path = file_path.parent.joinpath("calc_diff_msgram.csv")
 
     with open(file_path, "w", newline="") as csv_file:
-        fieldnames = ["repository", "version", "key", "planned", "developed", "diff"]
+        fieldnames = [
+            "repository",
+            "version",
+            "characteristic",
+            "planned",
+            "developed",
+            "diff",
+        ]
         writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
 
         writer.writeheader()
@@ -191,7 +198,10 @@ def export_csv(data_calculated: list, file_path: Path = Path("DEFAULT_CONFIG_PAT
                     {
                         "repository": data["repository"],
                         "version": data["version"],
-                        **row,
+                        "characteristic": row.get("key", ""),
+                        "planned": row.get("planned", ""),
+                        "developed": row.get("developed", ""),
+                        "diff": row.get("diff", ""),
                     }
                 )
 

{msgram-3.2.0 → msgram-3.2.2}/src/cli/commands/cmd_extract.py

@@ -102,7 +102,7 @@ def command_extract(args):
     if repository_path and output_origin == "github":
         filters = {
             "labels": label if label else "US,User Story,User Stories",
-            "workflows": workflows if workflows.split(',') else "build",
+            "workflows": workflows.split(",") if workflows else "build",
             "dates": filter_date if filter_date else None,
         }
         result = parser.parse(
@@ -132,6 +132,11 @@ def command_extract(args):
     logger.debug(f"extracted_path: {extracted_path}")
 
     files = list(data_path.glob("*.json"))
+
+    if not files:
+        print_warn(f"No JSON files found in the specified data_path: {data_path}\n")
+        sys.exit(1)
+
     valid_files = len(files)
 
     print_info(f"\n> Extract and save metrics [[blue ]{output_origin}[/]]:")

{msgram-3.2.0 → msgram-3.2.2}/src/cli/commands/cmd_norm_diff.py

@@ -43,26 +43,38 @@ def read_calculated_file(file_path):
 
 def command_norm_diff(args):
     try:
-        planned_path = args["planned_path"]
-        calculated_path = args["calculated_path"]
+        rp_path = args["rp_path"]
+        rd_path = args["rd_path"]
     except KeyError as e:
         logger.error(f"KeyError: args[{e}] - non-existent parameters")
         print_error(f"KeyError: args[{e}] - non-existent parameters")
         exit(1)
 
-    planned_data = read_planned_file(planned_path, sort_key="key")
-    calculated_data = read_calculated_file(calculated_path)
+    planned_data = read_planned_file(rp_path, sort_key="key")
+    calculated_data = read_calculated_file(rd_path)
 
-    planned_vector, calculated_vector = extract_values(planned_data, calculated_data)
+    planned_vector, calculated_vector = extract_values(
+        planned_data, calculated_data, rp_path, rd_path
+    )
     norm_diff_value = norm_diff(planned_vector, calculated_vector)
 
-    print_info("\n[#A9A9A9]Norm diff calculation performed successfully![/]")
-    print_info("[#A9A9A9]For more detailed informations use 'diff' command.[/]")
+    print_info("\n[#A9A9A9]Norm diff calculation performed successfully![/]\n")
+
+    print_info(
+        "[#A9A9A9]The norm_diff value indicates the difference between the observed "
+        "quality (Rd) and the planned target (Rp). A norm_diff of 0 means that the "
+        "observed quality perfectly aligns with the planned target. If norm_diff is "
+        "not equal to 0, it shows a deviation from the target. In this case, you "
+        "should determine whether the performance is above or below the planned "
+        "quality. For a detailed analysis of these differences, use the msgram diff "
+        "command.[/]\n"
+    )
+
     print(f"Norm Diff: {norm_diff_value}")
     print_rule()
 
 
-def extract_values(planned_data, calculated_data):
+def extract_values(planned_data, calculated_data, rp_path, rd_path):
     try:
         planned = planned_data
         calculated = []
@@ -86,6 +98,22 @@ def extract_values(planned_data, calculated_data):
         planned_values = [planned_dict[key] for key in planned_keys]
         calculated_values = [calculated_dict[key] for key in planned_keys]
 
+        for value in planned_values:
+            if value > 1 or value < 0:
+                print_error(
+                    f"[red]The values informed in the .json file {rp_path} must be between 0 and 1.\n"
+                )
+                print_rule()
+                exit(1)
+
+        for value in calculated_values:
+            if value > 1 or value < 0:
+                print_error(
+                    f"[red]The values informed in the .json file {rd_path} must be between 0 and 1.\n"
+                )
+                print_rule()
+                exit(1)
+
         return (np.array(planned_values), np.array(calculated_values))
     except exceptions.MeasureSoftGramCLIException as e:
         print_error(f"[red]Error extracting values: {e}\n")

{msgram-3.2.0 → msgram-3.2.2}/src/cli/jsonReader/jsonReader.py

@@ -29,8 +29,15 @@ def file_reader(path_file):
     return components
 
 
-def read_multiple_files(directory: Path, pattern: str):
-    for path_file in directory.glob(f"*.{pattern}"):
+def read_multiple_files(directory: Path, format: str, pattern: str):
+    if format == "github":
+        glob_pattern = f"github_*.{pattern}"
+    elif format == "sonarqube":
+        glob_pattern = f"[!github_]*.{pattern}"
+    else:
+        glob_pattern = f"*.{pattern}"
+
+    for path_file in directory.glob(glob_pattern):
         try:
             yield open_json_file(path_file), path_file.name
         except exceptions.MeasureSoftGramCLIException:

{msgram-3.2.0 → msgram-3.2.2}/src/cli/parsers.py

@@ -170,34 +170,51 @@ def create_parser():
         help="Path to the config directory",
     )
 
+    parser_calculate.add_argument(
+        "-in",
+        "--input_format",
+        required=True,
+        type=str,
+        choices=AVAILABLE_IMPORTS,
+        default="sonarqube",
+        help=(
+            "Format of .msgram files. Valid values are: " + ", ".join(AVAILABLE_IMPORTS)
+        ),
+    )
+
     parser_calculate.add_argument(
         "-o",
         "--output_format",
         type=str,
         choices=AVAILABLE_GEN_FORMATS,
         default="csv",
-        help=("The format of the output (export) values are: ".join(SUPPORTED_FORMATS)),
+        help=(
+            "The format of the output (export) values are: "
+            + ", ".join(SUPPORTED_FORMATS)
+        ),
     )
     parser_calculate.set_defaults(func=command_calculate)  # function command calculate
 
-    # =====================================< COMMAND norm-diff >=====================================
+    # =====================================< COMMAND norm_diff >=====================================
     parser_norm_diff = subparsers.add_parser(
-        "norm-diff",
+        "norm_diff",
         help="Calculate the norm difference between the planned metrics and the developed.",
     )
 
     parser_norm_diff.add_argument(
-        "-p",
-        "--planned_path",
+        "-rp",
+        "--rp_path",
         type=lambda p: Path(p).absolute(),
-        help="Path to the json with the planned metrics.",
+        help="Path to the .json file with the planned/wished values ​​for the quality "
+        "characteristics of a release. Quality requirements goals for a release.",
     )
 
     parser_norm_diff.add_argument(
-        "-c",
-        "--calculated_path",
+        "-rd",
+        "--rd_path",
         type=lambda p: Path(p).absolute(),
-        help="Path to the json with the calculated metrics.",
+        help="Path to the .json file with the model-calculated values ​​for a release's "
+        "quality characteristics observed/developed.",
     )
 
     parser_norm_diff.set_defaults(
@@ -211,28 +228,28 @@ def create_parser():
     )
 
     parser_calculate.add_argument(
-        "-ec",
-        "--extracted_calculation",
+        "-rd",
+        "--rd_path",
         type=lambda p: Path(p).absolute(),
-        help="Path to the calculated directory",
+        help="Path to the .json file with the model-calculated values for a release's quality"
+        "characteristics observed/developed.",
     )
 
     parser_calculate.add_argument(
-        "-cp",
-        "--config_path",
+        "-rp",
+        "--rp_path",
         type=lambda p: Path(p).absolute(),
-        default=DEFAULT_CONFIG_PATH,
-        help="Path to the config directory",
+        help="Path to the .json file with the planned/wished values for the quality characteristics"
+        "of a release. Quality requirements goals for a release.",
     )
 
     parser_calculate.add_argument(
-        "-o",
+        "-of",
         "--output_format",
         type=str,
         choices=AVAILABLE_GEN_FORMATS,
-        default="json",
-        help=("The format of the output (export) values are: ".join(SUPPORTED_FORMATS)),
+        help=("The format of the output (export) values is tabular"),
     )
-    parser_calculate.set_defaults(func=command_diff)  # function command calculate
+    parser_calculate.set_defaults(func=command_diff)
 
     return parser

msgram-3.2.2/src/cli/resources/characteristic.py

@@ -0,0 +1,40 @@
+from src.cli.resources.subcharacteristic import get_subcharacteristic_value
+
+from resources import calculate_characteristics as core_calculate
+
+
+def get_characteristic_value(chars, tsqmi):
+    char_calculated = []
+    for char in tsqmi:
+        char_key = char["key"]
+
+        found = any(char_key == m["key"] for m in chars)
+        if found:
+            char_calculated.append(
+                {
+                    "key": char_key,
+                    "value": {m["key"]: m["value"] for m in chars}[char_key],
+                    "weight": char["weight"],
+                }
+            )
+
+    return char_calculated
+
+
+def calculate_characteristics(config, subchars):
+    characteristics = config["characteristics"]
+    calculate_infos = []
+
+    for char in characteristics:
+        char_info = {
+            "key": char["key"],
+            "subcharacteristics": get_subcharacteristic_value(
+                subchars, char["subcharacteristics"]
+            ),
+        }
+        if len(char_info["subcharacteristics"]) > 0:
+            calculate_infos.append(char_info)
+
+    headers = ["Id", "Name", "Description", "Value", "Created at"]
+
+    return core_calculate({"characteristics": calculate_infos}), headers

{msgram-3.2.0 → msgram-3.2.2}/src/cli/resources/measure.py

@@ -12,13 +12,15 @@ def get_measure_value(measures, subchar):
     measures_calculated = []
     for measure in subchar:
         measure_key = measure["key"]
-        measures_calculated.append(
-            {
-                "key": measure_key,
-                "value": {m["key"]: m["value"] for m in measures}[measure_key],
-                "weight": measure["weight"],
-            }
-        )
+        found = any(measure_key == m["key"] for m in measures)
+        if found:
+            measures_calculated.append(
+                {
+                    "key": measure_key,
+                    "value": {m["key"]: m["value"] for m in measures}[measure_key],
+                    "weight": measure["weight"],
+                }
+            )
 
     return measures_calculated
 

{msgram-3.2.0 → msgram-3.2.2}/src/cli/resources/subcharacteristic.py

@@ -8,15 +8,17 @@ def get_subcharacteristic_value(subchars, char):
     for subchar in char:
         subchar_key = subchar["key"]
 
-        subchar_calculated.append(
-            {
-                "key": subchar_key,
-                "value": {m["key"]: m["value"] for m in subchars}.get(
-                    subchar_key, None
-                ),
-                "weight": subchar["weight"],
-            }
-        )
+        found = any(subchar_key == m["key"] for m in subchars)
+        if found:
+            subchar_calculated.append(
+                {
+                    "key": subchar_key,
+                    "value": {m["key"]: m["value"] for m in subchars}.get(
+                        subchar_key, None
+                    ),
+                    "weight": subchar["weight"],
+                }
+            )
 
     return subchar_calculated
 
@@ -32,7 +34,9 @@ def calculate_subcharacteristics(config, measures):
                     "key": subchar["key"],
                     "measures": get_measure_value(measures, subchar["measures"]),
                 }
-                calculate_infos.append(subchar_info)
+                if len(subchar_info["measures"]) > 0:
+                    calculate_infos.append(subchar_info)
 
     headers = ["Id", "Name", "Description", "Value", "Created at"]
+
     return core_calculate({"subcharacteristics": calculate_infos}), headers