RepoAuditor 0.2.22__tar.gz → 0.2.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RepoAuditor
-Version: 0.2.22
+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.22 → repoauditor-0.2.23}/pyproject.toml

@@ -119,7 +119,7 @@ select = [
     "PTH",
     "FLY",
     "I",
-    # "C90", # 3
+    "C90",
     "NPY",
     "PD",
     "N",

{repoauditor-0.2.22 → 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.22 → 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
 
 

{repoauditor-0.2.22 → repoauditor-0.2.23}/src/RepoAuditor/ExecuteModules.py

@@ -8,7 +8,6 @@
 
 import itertools
 import sys
-import textwrap
 
 from dataclasses import dataclass
 from typing import Any, cast, Optional
@@ -18,10 +17,6 @@ from dbrownell_Common import ExecuteTasks  # type: ignore[import-untyped]
 from dbrownell_Common.InflectEx import inflect  # type: ignore[import-untyped]
 from dbrownell_Common.Streams.Capabilities import Capabilities  # type: ignore[import-untyped]
 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 rich.progress import Progress, TimeElapsedColumn
 
 from .Module import EvaluateResult, ExecutionStyle, Module, OnStatusFunc
@@ -46,6 +41,66 @@ class ModuleInfo:
 # |  Public Functions
 # |
 # ----------------------------------------------------------------------
+
+
+# ----------------------------------------------------------------------
+def Evaluate(
+    module_info: ModuleInfo,
+    on_status_func: OnStatusFunc,
+    max_num_threads: Optional[int],
+) -> list[list[Module.EvaluateInfo]]:
+    """Evaluate the module given the dynamic arguments.
+
+    Returns a list of information pertaining to module evaluation,
+    with it subgrouped as lists themselves, hence a list of lists.
+    """
+    module_data = module_info.module.GenerateInitialData(module_info.dynamic_args)
+    if module_data is None:
+        return []
+
+    return module_info.module.Evaluate(
+        module_data,
+        module_info.requirement_args,
+        on_status_func,
+        max_num_threads=max_num_threads,
+    )
+
+
+# ----------------------------------------------------------------------
+def CalcResultInfo(
+    all_eval_infos: list[list[Module.EvaluateInfo]],
+    warnings_as_errors_module_names: set[str],
+    ignore_warnings_module_names: set[str],
+) -> tuple[int, str]:
+    """Calculate the result of evaluating the modules as given in `all_eval_infos`.
+
+    Returns a code value indicating success, warning, or error,
+    as well as a string description of the result.
+    """
+    return_code = 0
+
+    if not all_eval_infos:
+        return 0, "module does not apply"
+
+    for eval_infos in all_eval_infos:
+        for eval_info in eval_infos:
+            result = eval_info.result
+
+            if result == EvaluateResult.Warning:
+                if eval_info.module.name in warnings_as_errors_module_names:
+                    result = EvaluateResult.Error
+                elif eval_info.module.name in ignore_warnings_module_names:
+                    continue
+
+            if result == EvaluateResult.Error:
+                return -1, "errors were encountered"
+
+            if result == EvaluateResult.Warning:
+                return_code = 1
+
+    return return_code, "" if return_code == 0 else "warnings were encountered"
+
+
 def Execute(
     dm: DoneManager,
     module_infos: list[ModuleInfo],
@@ -82,52 +137,7 @@ def Execute(
             parallel = []
 
         # Calculate the results
-
         # ----------------------------------------------------------------------
-        def Evaluate(
-            module_info: ModuleInfo,
-            on_status_func: OnStatusFunc,
-        ) -> list[list[Module.EvaluateInfo]]:
-            module_data = module_info.module.GenerateInitialData(module_info.dynamic_args)
-            if module_data is None:
-                return []
-
-            return module_info.module.Evaluate(
-                module_data,
-                module_info.requirement_args,
-                on_status_func,
-                max_num_threads=max_num_threads,
-            )
-
-        # ----------------------------------------------------------------------
-        def CalcResultInfo(
-            all_eval_infos: list[list[Module.EvaluateInfo]],
-        ) -> tuple[int, str]:
-            return_code = 0
-
-            if not all_eval_infos:
-                return 0, "module does not apply"
-
-            for eval_infos in all_eval_infos:
-                for eval_info in eval_infos:
-                    result = eval_info.result
-
-                    if result == EvaluateResult.Warning:
-                        if eval_info.module.name in warnings_as_errors_module_names:
-                            result = EvaluateResult.Error
-                        elif eval_info.module.name in ignore_warnings_module_names:
-                            continue
-
-                    if result == EvaluateResult.Error:
-                        return -1, "errors were encountered"
-
-                    if result == EvaluateResult.Warning:
-                        return_code = 1
-
-            return return_code, "" if return_code == 0 else "warnings were encountered"
-
-        # ----------------------------------------------------------------------
-
         all_results: list[Optional[list[list[Module.EvaluateInfo]]]] = [None] * len(module_infos)
 
         if parallel:
@@ -152,9 +162,13 @@ def Execute(
 
                     # ----------------------------------------------------------------------
 
-                    evaluate_results = Evaluate(module_info, OnStatus)
+                    evaluate_results = Evaluate(module_info, OnStatus, max_num_threads=max_num_threads)
 
-                    result_code, result_status = CalcResultInfo(evaluate_results)
+                    result_code, result_status = CalcResultInfo(
+                        evaluate_results,
+                        warnings_as_errors_module_names=warnings_as_errors_module_names,
+                        ignore_warnings_module_names=ignore_warnings_module_names,
+                    )
 
                     return ExecuteTasks.TransformResultComplete(evaluate_results, result_code, result_status)
 
@@ -186,11 +200,7 @@ def Execute(
         for index, (all_results_index, module_info) in enumerate(sequential):
             with (
                 modules_dm.Nested(
-                    "Processing '{}' ({} of {})...".format(
-                        module_info.module.name,
-                        index + 1 + len(parallel),
-                        len(module_infos),
-                    ),
+                    f"Processing '{module_info.module.name}' ({index + 1 + len(parallel)} of {len(module_infos)})...",
                 ) as this_module_dm,
                 # rich.progress needs to output to sys.stdout
                 this_module_dm.YieldStdout() as stdout_context,
@@ -243,12 +253,16 @@ def Execute(
 
                     # ----------------------------------------------------------------------
 
-                    evaluate_results = Evaluate(module_info, OnStatus)
+                    evaluate_results = Evaluate(module_info, OnStatus, max_num_threads=max_num_threads)
 
                     assert all_results[all_results_index] is None
                     all_results[all_results_index] = evaluate_results
 
-                    this_module_dm.result = CalcResultInfo(evaluate_results)[0]
+                    this_module_dm.result = CalcResultInfo(
+                        evaluate_results,
+                        warnings_as_errors_module_names=warnings_as_errors_module_names,
+                        ignore_warnings_module_names=ignore_warnings_module_names,
+                    )[0]
 
     final_results: list[list[Module.EvaluateInfo]] = []
 
@@ -261,124 +275,6 @@ def Execute(
     return final_results
 
 
-# ----------------------------------------------------------------------
-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] = []
-
-        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,
-                ),
-            )
-
-        rich_print(
-            Panel(
-                Group(*internal_content),
-                padding=1 if internal_content else 0,
-                title=results[0].module.name,
-                width=panel_width,
-            ),
-        )
-
-
 # ----------------------------------------------------------------------
 # ----------------------------------------------------------------------
 # ----------------------------------------------------------------------

{repoauditor-0.2.22 → repoauditor-0.2.23}/src/RepoAuditor/__init__.py

@@ -3,4 +3,4 @@ APP_NAME = "RepoAuditor"
 # Note that this value will be overwritten by calls to `python ../../Build.py update_version` based
 # on changes observed in the git repository. The default value below will be used until the value
 # here is explicitly updated by the Continuous Integration system.
-__version__ = "0.2.22"
+__version__ = "0.2.23"

{repoauditor-0.2.22 → repoauditor-0.2.23}/tests/ExecuteModules_UnitTest.py

@@ -20,6 +20,7 @@ from dbrownell_Common.TestHelpers.StreamTestHelpers import (
     InitializeStreamCapabilities,
 )
 
+from RepoAuditor.Display import *
 from RepoAuditor.ExecuteModules import *
 from RepoAuditor.Module import *
 from RepoAuditor.Requirement import *