RepoAuditor 0.2.22__tar.gz → 0.2.24__tar.gz

{repoauditor-0.2.22 → repoauditor-0.2.24}/.github/workflows/CICD.yml

@@ -36,4 +36,3 @@ jobs:
       MINISIGN_PRIVATE_KEY: ${{ secrets.MINISIGN_PRIVATE_KEY }}
       PYPI_PUBLISH_TOKEN: ${{ secrets.PYPI_PUBLISH_TOKEN }}
       COVERAGE_BADGE_GIST_TOKEN: ${{ secrets.COVERAGE_BADGE_GIST_TOKEN }}
-      TESTING_GITHUB_PAT: ${{ secrets.TESTING_GITHUB_PAT }}

{repoauditor-0.2.22 → repoauditor-0.2.24}/.github/workflows/CICD_impl.yml

@@ -41,10 +41,6 @@ on:
         required: false
         description: "Token used to access the Gist used to store coverage badge information. Code coverage information will not be persisted if this value is missing."
 
-      TESTING_GITHUB_PAT:
-        required: true
-        description: "GitHub PAT used by tests to access the repository. This value is required."
-
 jobs:
   # ----------------------------------------------------------------------
   validate:
@@ -70,30 +66,11 @@ jobs:
           python-version: ${{ matrix.python_version }}
           enable-cache: true
 
-      # Ensure that the github PAT is available for the tests
-      - name: Create github_pat.txt
-        run: |
-          echo ${{ secrets.TESTING_GITHUB_PAT }} > tests/Plugins/github_pat.txt
-
-      - name: Environment Variables (!Windows)
-        shell: bash
-        if: ${{ ! startsWith(matrix.os, 'windows') }}
-        run: |
-          echo "GITHUB_CI_OPERATING_SYSTEM=${{ matrix.os }}" >> $GITHUB_ENV
-          echo "GITHUB_CI_PYTHON_VERSION=${{ matrix.python_version }}" >> $GITHUB_ENV
-
-      - name: Environment Variables (Windows)
-        shell: cmd
-        if: ${{ startsWith(matrix.os, 'windows') }}
-        run: |
-          echo GITHUB_CI_OPERATING_SYSTEM=${{ matrix.os }} >> %GITHUB_ENV%
-          echo GITHUB_CI_PYTHON_VERSION=${{ matrix.python_version }} >> %GITHUB_ENV%
-
       - name: Run pre-commit scripts
         run: uv run pre-commit run --verbose
 
       - name: Validate Tests
-        run: uv run pytest
+        run: uv run pytest -k 'not EndToEndTest' --cov-fail-under=80.0
         env:
           COVERAGE_FILE: .coverage.${{ matrix.os }}.${{ matrix.python_version }}
 

repoauditor-0.2.24/.github/workflows/EndToEnd.yml

@@ -0,0 +1,48 @@
+name: "End To End Tests"
+run-name: EndToEnd ${{ github.run_number }} [${{ github.actor }}] on ${{ github.ref_name }}
+
+on:
+  schedule:
+    - cron: '0 * * * *' # Once every hour
+  workflow_dispatch:
+
+jobs:
+  validate:
+    strategy:
+      fail-fast: false
+
+      matrix:
+        # Since the system under test here is the GitHub API, it is sufficient to test using only a single OS.
+        os: ["ubuntu-latest"]
+        # Similar to OS, we only test the lowest and highest supported versions.
+        python_version: ["3.10", "3.13"]
+
+    name: Validate
+    runs-on: ${{ matrix.os }}
+
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv and python
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python_version }}
+          enable-cache: true
+
+      # Ensure that the github PAT is available for the tests
+      # GitHub PAT used by tests to access the repository.
+      - name: Create github_pat.txt
+        run: |
+          echo ${{ secrets.TESTING_GITHUB_PAT }} > tests/Plugins/github_pat.txt
+
+      - name: Environment Variables
+        shell: bash
+        run: |
+          echo "GITHUB_CI_OPERATING_SYSTEM=${{ matrix.os }}" >> $GITHUB_ENV
+          echo "GITHUB_CI_PYTHON_VERSION=${{ matrix.python_version }}" >> $GITHUB_ENV
+
+      - name: Validate Tests
+        run: uv run pytest -k EndToEndTest --no-cov

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

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

@@ -83,7 +83,7 @@ select = [
     "ASYNC",
     "S",
     "BLE",
-    # "FBT", # 44
+    "FBT",
     "B",
     "A",
     "COM",
@@ -119,7 +119,7 @@ select = [
     "PTH",
     "FLY",
     "I",
-    # "C90", # 3
+    "C90",
     "NPY",
     "PD",
     "N",
@@ -148,6 +148,7 @@ ignore = [
     "D107", # Missing docstring in `__init__` method
     "D202", # No blank lines allowed after function docstring
     "E501", # Line too long
+    "FBT003", # Boolean positional argument in function call
     "I001", # Import block is un-sorted or un-formatted
     "N802", # Function name `xxx` should be lowercase
     "N999", # Invalid module name

{repoauditor-0.2.22 → repoauditor-0.2.24}/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.24/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,  # noqa: FBT001
+    display_rationale: bool,  # noqa: FBT001
+    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.24}/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
 
 
@@ -168,7 +168,7 @@ def _HelpEpilog() -> str:
 
 
 # ----------------------------------------------------------------------
-def _VersionCallback(value: bool) -> None:
+def _VersionCallback(value: bool) -> None:  # noqa: FBT001
     if value:
         sys.stdout.write(f"RepoAuditor v{__version__}\n")
         raise typer.Exit()
@@ -184,7 +184,7 @@ def _VersionCallback(value: bool) -> None:
 )
 def EntryPoint(
     ctx: typer.Context,
-    version: Annotated[  # noqa: ARG001
+    version: Annotated[  # noqa: ARG001, FBT002
         bool,
         typer.Option(
             "--version",
@@ -221,38 +221,38 @@ def EntryPoint(
             help="Name of a module whose warnings should be ignored. This value can be provided multiple times.",
         ),
     ] = None,
-    all_warnings_as_error: Annotated[
+    all_warnings_as_error: Annotated[  # noqa: FBT002
         bool, typer.Option("--all-warnings-as-error", help="Treat all warnings as errors.")
     ] = False,
-    ignore_all_warnings: Annotated[
+    ignore_all_warnings: Annotated[  # noqa: FBT002
         bool, typer.Option("--ignore-all-warnings", help="Ignore all warnings.")
     ] = False,
-    single_threaded: Annotated[
+    single_threaded: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--single-threaded", help="Do not use multiple threads when evaluating requirements."),
     ] = False,
-    no_resolution: Annotated[
+    no_resolution: Annotated[  # noqa: FBT002
         bool,
         typer.Option(
             "--no-resolution",
             help="Do not display resolution information for requirements that are not successful.",
         ),
     ] = False,
-    no_rationale: Annotated[
+    no_rationale: Annotated[  # noqa: FBT002
         bool,
         typer.Option(
             "--no-rationale",
             help="Do not display rationale information for requirements that are not successful.",
         ),
     ] = False,
-    verbose: Annotated[
+    verbose: Annotated[  # noqa: FBT002
         bool,
         typer.Option(
             "--verbose",
             help="Write verbose information to the terminal.",
         ),
     ] = False,
-    debug: Annotated[
+    debug: Annotated[  # noqa: FBT002
         bool,
         typer.Option(
             "--debug",