RepoAuditor 0.2.21__tar.gz → 0.2.23__tar.gz

{repoauditor-0.2.21 → repoauditor-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.21
+Version: 0.2.23
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/gt-sse-center/RepoAuditor
 Project-URL: Documentation, https://github.com/gt-sse-center/RepoAuditor

{repoauditor-0.2.21 → repoauditor-0.2.23}/pyproject.toml

@@ -76,7 +76,7 @@ exclude = ["tests/**"]
 # ...however, we current experience failures in the rulesets commented out below.
 select = [
     "AIR",
-    #"ERA", # 168
+    "ERA",
     "FAST",
     "YTT",
     "ANN",
@@ -119,7 +119,7 @@ select = [
     "PTH",
     "FLY",
     "I",
-    # "C90", # 3
+    "C90",
     "NPY",
     "PD",
     "N",

{repoauditor-0.2.21 → repoauditor-0.2.23}/src/RepoAuditor/CommandLineProcessor.py

@@ -36,38 +36,15 @@ class CommandLineProcessor:
             ],  # actual type is dict[str, TyperEx.TypeDefinitionItemType]
         ) -> dict[str, Any]: ...
 
-    # ----------------------------------------------------------------------
-    # |
-    # |  Public Data
-    # |
-    # ----------------------------------------------------------------------
-    module_infos: list[ModuleInfo]
-    warnings_as_error_module_names: set[str]
-    ignore_warnings_module_names: set[str]
-    single_threaded: bool = field(kw_only=True)
-
-    # ----------------------------------------------------------------------
-    # |
-    # |  Public Methods
-    # |
-    # ----------------------------------------------------------------------
-    @classmethod
-    def Create(
-        cls,
-        get_dynamic_args_func: "CommandLineProcessor.GetDynamicArgsFunc",
+    @staticmethod
+    def _GetModuleMap(
         modules: list[Module],
-        includes: list[str],
-        excludes: list[str],
-        warnings_as_error_module_names: set[str],
-        ignore_warnings_module_names: set[str],
-        *,
-        all_warnings_as_error: bool = False,
-        ignore_all_warnings: bool = False,
-        single_threaded: bool = False,
-        argument_separator: str = "-",
-    ) -> "CommandLineProcessor":
-        """Factor method to construct a CommandLineProcessor object."""
-        # Convert modules into a lookup map
+        argument_separator: str,
+    ) -> dict[str, Module]:
+        """Convert modules into a lookup map.
+
+        Returns a dict of module names mapped to the corresponding module.
+        """
         module_map: dict[str, Module] = {}
 
         for module in modules:
@@ -75,16 +52,26 @@ class CommandLineProcessor:
                 msg = f"The module name '{module.name}' contains '{argument_separator}', which should be used as an argument separator."
                 raise ValueError(msg)
 
-            prev_module = module_map.get(module.name, None)
-            if prev_module is not None:
+            prev_added_module = module_map.get(module.name, None)
+            if prev_added_module is not None:
                 msg = f"The module '{module.name}' has already been defined."
                 raise ValueError(msg)
 
             module_map[module.name] = module
 
-        del modules
+        return module_map
 
-        # Process includes
+    @staticmethod
+    def _ProcessIncludes(
+        module_map: dict[str, Module],
+        includes: list[str],
+        argument_separator: str,
+    ) -> tuple[set[str], dict[str, set[str]]]:
+        """Process the modules and requirements to include.
+
+        Returns both the set of names of the included modules as well as
+        the dictionary of module names mapped to the set of included requirement names.
+        """
         included_modules: set[str] = set()
         included_requirements: dict[str, set[str]] = {}
 
@@ -103,16 +90,19 @@ class CommandLineProcessor:
                     argument_separator.join(parts[1:])
                 )
 
-        del includes
+        return included_modules, included_requirements
 
-        for module_name, module in list(module_map.items()):
-            if module.requires_explicit_include and module_name not in included_modules:
-                module_map.pop(module_name)
-                continue
-
-        del included_modules
+    @staticmethod
+    def _ProcessExcludes(
+        module_map: dict[str, Module],
+        excludes: list[str],
+        argument_separator: str,
+    ) -> dict[str, set[str]]:
+        """Process the modules and requirements to exclude.
 
-        # Process excludes
+        Returns both the set of names of the excluded modules as well as
+        the dictionary of module names mapped to the set of excluded requirement names.
+        """
         excluded_requirements: dict[str, set[str]] = {}
 
         for exclude in excludes:
@@ -130,27 +120,20 @@ class CommandLineProcessor:
                     argument_separator.join(parts[1:])
                 )
 
-        del excludes
-
-        # Add / Remove the requirements for each module
-        for module_name, module in list(module_map.items()):
-            module.ProcessRequirements(
-                included_requirements.get(module_name, set()),
-                excluded_requirements.get(module_name, set()),
-            )
+        return excluded_requirements
 
-            if module.GetNumRequirements() == 0:
-                module_map.pop(module_name)
-
-        del included_requirements
-        del excluded_requirements
-
-        if all_warnings_as_error:
-            warnings_as_error_module_names = {module.name for module in module_map.values()}
-        if ignore_all_warnings:
-            ignore_warnings_module_names = {module.name for module in module_map.values()}
+    @staticmethod
+    def _ProcessDynamicArguments(
+        module_map: dict[str, Module],
+        argument_separator: str,
+        get_dynamic_args_func: "CommandLineProcessor.GetDynamicArgsFunc",
+    ) -> dict[str, dict[str, Any]]:
+        """Process the passed in dynamic arguments.
 
-        # Create the type definitions
+        Returns a dictionary of module names to a corresponding dictionary
+        of argument names to values.
+        """
+        # First we create the type definitions
         dynamic_arg_definitions: dict[str, Any] = {}
 
         for module in module_map.values():
@@ -166,7 +149,7 @@ class CommandLineProcessor:
                             f"{module.name}{argument_separator}{requirement.name}{argument_separator}{key}"
                         ] = value
 
-        # Process the dynamic info
+        # Now we process the definitions to get the dynamic arguments
         dynamic_args: dict[str, dict[str, Any]] = {}
 
         for key, value in get_dynamic_args_func(dynamic_arg_definitions).items():
@@ -185,6 +168,88 @@ class CommandLineProcessor:
                     {},
                 )[argument_separator.join(parts[2:])] = value
 
+        return dynamic_args
+
+    # ----------------------------------------------------------------------
+    # |
+    # |  Public Data
+    # |
+    # ----------------------------------------------------------------------
+    module_infos: list[ModuleInfo]
+    warnings_as_error_module_names: set[str]
+    ignore_warnings_module_names: set[str]
+    single_threaded: bool = field(kw_only=True)
+
+    # ----------------------------------------------------------------------
+    # |
+    # |  Public Methods
+    # |
+    # ----------------------------------------------------------------------
+    @classmethod
+    def Create(
+        cls,
+        get_dynamic_args_func: "CommandLineProcessor.GetDynamicArgsFunc",
+        modules: list[Module],
+        includes: list[str],
+        excludes: list[str],
+        warnings_as_error_module_names: set[str],
+        ignore_warnings_module_names: set[str],
+        *,
+        all_warnings_as_error: bool = False,
+        ignore_all_warnings: bool = False,
+        single_threaded: bool = False,
+        argument_separator: str = "-",
+    ) -> "CommandLineProcessor":
+        """Factor method to construct a CommandLineProcessor object."""
+        # Convert modules into a lookup map
+        module_map: dict[str, Module] = cls._GetModuleMap(modules, argument_separator)
+
+        del modules
+
+        # Process includes
+        included_modules, included_requirements = cls._ProcessIncludes(
+            module_map, includes, argument_separator
+        )
+
+        del includes
+
+        for module_name, module in list(module_map.items()):
+            if module.requires_explicit_include and module_name not in included_modules:
+                module_map.pop(module_name)
+                continue
+
+        del included_modules
+
+        # Process excludes
+        excluded_requirements: dict[str, set[str]] = cls._ProcessExcludes(
+            module_map, excludes, argument_separator
+        )
+
+        del excludes
+
+        # Add / Remove the requirements for each module
+        for module_name, module in list(module_map.items()):
+            module.ProcessRequirements(
+                included_requirements.get(module_name, set()),
+                excluded_requirements.get(module_name, set()),
+            )
+
+            if module.GetNumRequirements() == 0:
+                module_map.pop(module_name)
+
+        del included_requirements
+        del excluded_requirements
+
+        if all_warnings_as_error:
+            warnings_as_error_module_names = {module.name for module in module_map.values()}
+        if ignore_all_warnings:
+            ignore_warnings_module_names = {module.name for module in module_map.values()}
+
+        # Process the dynamic info
+        dynamic_args: dict[str, dict[str, Any]] = cls._ProcessDynamicArguments(
+            module_map, argument_separator, get_dynamic_args_func
+        )
+
         module_infos: list[ModuleInfo] = []
 
         for module_name, module in module_map.items():

repoauditor-0.2.23/src/RepoAuditor/Display.py

@@ -0,0 +1,165 @@
+# -------------------------------------------------------------------------------
+# |
+# |  Copyright (c) 2024 Scientific Software Engineering Center at Georgia Tech
+# |  Distributed under the MIT License.
+# |
+# -------------------------------------------------------------------------------
+"""Contains functionality to display the results of executing modules."""
+
+import textwrap
+from typing import Optional
+
+from dbrownell_Common.Streams.DoneManager import DoneManager  # type: ignore[import-untyped]
+from dbrownell_Common import TextwrapEx  # type: ignore[import-untyped]
+from rich import print as rich_print
+from rich.console import Group
+from rich.panel import Panel
+
+from .Module import EvaluateResult, Module
+
+
+def GetInternalPanelContent(
+    dm: DoneManager,
+    results: list[Module.EvaluateInfo],
+    display_resolution: bool,
+    display_rationale: bool,
+    num_success: int,
+    num_warning: int,
+    num_error: int,
+    num_does_not_apply: int,
+    num_requirements: int,
+) -> list[Panel | str]:
+    """Get the content for each result to be displayed inside the internal panel."""
+    internal_content: list[Panel | str] = []
+
+    module = results[0].module
+
+    if module.description:
+        internal_content.append(f"{module.description.strip()}\n")
+
+    internal_content.append(
+        textwrap.dedent(
+            f"""\
+                Successful:     {num_success} ({(num_success / num_requirements):.02%})
+                Warnings:       {num_warning} ({(num_warning / num_requirements):.02%})
+                Errors:         {num_error} ({(num_error / num_requirements):.02%})
+                Skipped:        {num_does_not_apply} ({(num_does_not_apply / num_requirements):.02%})
+                """,
+        ),
+    )
+
+    for result in results:
+        if not dm.is_verbose and result.result in [
+            EvaluateResult.Success,
+            EvaluateResult.DoesNotApply,
+        ]:
+            continue
+
+        if result.result == EvaluateResult.Success:
+            border_color = "green"
+        elif result.result == EvaluateResult.Warning:
+            border_color = "yellow"
+        elif result.result == EvaluateResult.Error:
+            border_color = "red"
+        elif result.result == EvaluateResult.DoesNotApply:
+            border_color = ""
+        else:
+            raise RuntimeError(result.result)  # pragma: no cover
+
+        content: list[str] = []
+
+        if result.requirement.description:
+            content.append(f"{result.requirement.description.strip()}\n")
+
+        if result.context:
+            content.append(f"{result.result.name.upper()}: {result.context.strip()}\n")
+
+        if display_resolution and result.resolution:
+            content.append(
+                textwrap.dedent(
+                    """\
+                        Resolution
+                        ----------
+                          {}
+                        """,
+                ).format(TextwrapEx.Indent(result.resolution.strip(), 2, skip_first_line=True)),
+            )
+
+        if display_rationale and result.rationale:
+            content.append(
+                textwrap.dedent(
+                    """\
+                        Rationale
+                        ---------
+                          {}
+                        """,
+                ).format(TextwrapEx.Indent(result.rationale.strip(), 2, skip_first_line=True)),
+            )
+
+        internal_content.append(
+            Panel(
+                Group(*content),
+                title=f"[{result.result.name}] {result.requirement.name}",
+                title_align="left",
+                border_style=border_color,
+                padding=(1, 1, 0, 1) if content else 0,
+            ),
+        )
+
+    return internal_content
+
+
+# ----------------------------------------------------------------------
+def DisplayResults(
+    dm: DoneManager,
+    all_results: list[list[Module.EvaluateInfo]],
+    *,
+    display_resolution: bool,
+    display_rationale: bool,
+    panel_width: Optional[int] = None,
+) -> None:
+    """Display the results of executing the modules."""
+    for results in all_results:
+        assert results
+        module = results[0].module
+
+        num_success = 0
+        num_warning = 0
+        num_error = 0
+        num_does_not_apply = 0
+
+        for result in results:
+            if result.result == EvaluateResult.Success:
+                num_success += 1
+            elif result.result == EvaluateResult.Warning:
+                num_warning += 1
+            elif result.result == EvaluateResult.Error:
+                num_error += 1
+            elif result.result == EvaluateResult.DoesNotApply:
+                num_does_not_apply += 1
+            else:
+                raise RuntimeError(result.result)  # pragma: no cover
+
+        num_requirements = module.GetNumRequirements()
+        assert num_requirements
+
+        internal_content: list[Panel | str] = GetInternalPanelContent(
+            dm,
+            results,
+            display_resolution,
+            display_rationale,
+            num_success=num_success,
+            num_warning=num_warning,
+            num_error=num_error,
+            num_does_not_apply=num_does_not_apply,
+            num_requirements=num_requirements,
+        )
+
+        rich_print(
+            Panel(
+                Group(*internal_content),
+                padding=1 if internal_content else 0,
+                title=results[0].module.name,
+                width=panel_width,
+            ),
+        )

{repoauditor-0.2.21 → repoauditor-0.2.23}/src/RepoAuditor/EntryPoint.py

@@ -23,7 +23,7 @@ from typer.core import TyperGroup  # type: ignore [import-untyped]
 
 from RepoAuditor import APP_NAME, __version__
 from RepoAuditor.CommandLineProcessor import CommandLineProcessor, Module
-from RepoAuditor.ExecuteModules import DisplayResults
+from RepoAuditor.Display import DisplayResults
 from RepoAuditor import Plugin