pluginify 0.0.0.post1.dev0__tar.gz → 0.1.0.post11.dev0__tar.gz

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/.github/workflows/package-and-publish.yaml

@@ -26,6 +26,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # make poetry dynamic versioning actually see our git tags
 
       - uses: actions/setup-python@v5
         with:

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/PKG-INFO

@@ -1,15 +1,17 @@
 Metadata-Version: 2.4
 Name: pluginify
-Version: 0.0.0.post1.dev0
+Version: 0.1.0.post11.dev0
 Summary: Pluginify package
 License: LICENSE
 License-File: LICENSE
 Author: Evan Rose
-Requires-Python: >=3.11.0,<3.13.0
+Requires-Python: >=3.11.0
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: doc
 Requires-Dist: docstring_parser
 Requires-Dist: jsonschema (>4.18.0)
@@ -49,9 +51,9 @@ git clone https://github.com/NRLMMD-GEOIPS/pluginify.git
 # cd to pluginify's top level dir
 pip install -e .
 ```
-In the future:
+OR
 ```bash
-    pip install pluginify
+pip install pluginify
 ```
 
 Use pluginify

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/README.md

@@ -25,9 +25,9 @@ git clone https://github.com/NRLMMD-GEOIPS/pluginify.git
 # cd to pluginify's top level dir
 pip install -e .
 ```
-In the future:
+OR
 ```bash
-    pip install pluginify
+pip install pluginify
 ```
 
 Use pluginify

pluginify-0.1.0.post11.dev0/docs/source/releases/latest/ignore-dot-files-and-dirs.yaml

@@ -0,0 +1,17 @@
+enhancement:
+- title: 'Omit dot files and directories from registry.'
+  description: |
+    Updated plugin registry code to ignore any instance of dot files or directories
+    from the plugin registry. This is a minor update to prevent .ipynb files and other
+    irrelevant files from sometimes leaking into the registry and causing problems
+    (such as duplicate keys).
+  files:
+    modified:
+      - pluginify/create_plugin_registries.py
+  related-issue:
+    number: null
+    repo_url: ''
+  date:
+    start: null
+    finish: null
+

pluginify-0.1.0.post11.dev0/docs/source/releases/latest/obp-plugin-registry-updates.yaml

@@ -0,0 +1,18 @@
+enhancement:
+- title: 'Migrate OBP "expand" functionality to pluginify.'
+  description: |
+    Direct copy over of changes made in a GeoIPS PR to the plugin_registry.py file.
+
+    Changes made added support for pluginify to dynamically 'expand' a workflow if a
+    product, product_default, or workflow was found within a workflow plugin. This is
+    only done if the '_expand' argument is set to True, which is done via the
+    'geoips expand <workflow_name>' command.
+  files:
+    modified:
+      - pluginify/plugin_registry.py
+  related-issue:
+    number: null
+    repo_url: ''
+  date:
+    start: null
+    finish: null

pluginify-0.1.0.post11.dev0/docs/source/releases/latest/pluginify-updates-jeremy-comments.yaml

@@ -0,0 +1,27 @@
+documentation:
+- title: 'Minor updates to pluginify CLI and unit tests'
+  description: |
+    Updates to CLI help information and refactoring of plugin registry unit test code.
+
+    Moved PluginRegistryValidator class to a utility module so packages outside of
+    pluginify could make use of that code.
+
+    Updating CLI commands help information by providing examples and more context.
+
+    Removed <3.13 restriction for python.
+  files:
+    added:
+      - pluginify/utils/validators.py
+    modified:
+      - docs/source/concepts/command_line/index.rst
+      - docs/source/concepts/functionality/index.rst
+      - pluginify/commandline_typer.py
+      - tests/unit_tests/plugin_registries/test_plugin_registries.py
+      - README.md
+      - pyproject.toml
+  related-issue:
+    number: null
+    repo_url: ''
+  date:
+    start: null
+    finish: null

pluginify-0.1.0.post11.dev0/docs/source/releases/latest/pypi-publish-bug-fix.yaml

@@ -0,0 +1,15 @@
+continuous integration:
+- title: 'PyPi Publish bug fix'
+  description: |
+    Updated package-and-publish.yaml workflow to recognize dynamic versioning via git
+    tags. Hopefully this will work.
+  files:
+    modified:
+      - .github/workflows/package-and-publish.yaml
+      - pyproject.toml
+  related-issue:
+    number: null
+    repo_url: ''
+  date:
+    start: null
+    finish: null

pluginify-0.1.0.post11.dev0/docs/source/releases/latest/version-update.yaml

@@ -0,0 +1,15 @@
+continuous integration:
+- title: 'Pluginify Version Update'
+  description: |
+    Updated package version from v0.0.0 to v1.0.0. Needed to push most up to date code
+    to PyPi.
+  files:
+    modified:
+      - pluginify/_version.py
+      - pyproject.toml
+  related-issue:
+    number: null
+    repo_url: ''
+  date:
+    start: null
+    finish: null

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/pluginify/_version.py

@@ -3,5 +3,5 @@
 
 # DO NOT EDIT
 # managed by poetry-dynamic-versioning
-__version__ = "0.0.0.post1.dev0"
-__version_tuple__ = (0, 0, 0, "post1", "dev0")
+__version__ = "0.1.0.post11.dev0"
+__version_tuple__ = (0, 1, 0, "post11", "dev0")

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/pluginify/commandline_typer.py

@@ -56,8 +56,8 @@ def configure_logging(level=logging.INFO):
     root = logging.getLogger()
 
     # Avoid duplicate handlers if CLI is called multiple times
-    if root.handlers:
-        return
+    # if root.handlers:
+    #     return
 
     root.setLevel(level)
 
@@ -131,6 +131,10 @@ class DocstringTyper(typer.Typer):
             if doc.long_description:
                 new_doc += "\n\n" + doc.long_description
 
+            # Keep examples portion in command's help output if specified
+            if doc.examples:
+                new_doc += "\n\nExamples\n--------\n" + doc.examples[0].description
+
             func.__doc__ = new_doc
 
             new_params = []
@@ -165,10 +169,32 @@ class DocstringTyper(typer.Typer):
         return wrapper
 
 
-app = DocstringTyper(context_settings={"help_option_names": ["-h", "--help"]})
+app = DocstringTyper(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="pluginify command line interface.",
+)
 config_app = DocstringTyper()
-
-app.add_typer(config_app, name="config", help="Configuration commands for pluginify.")
+config_set_app = DocstringTyper()
+
+config_variable_help = (
+    "NAMESPACE specifies the default namespace in which pluginify will manage "
+    "registries.\n"
+    "REGISTRY_DIRECTORY specifies the base directory where registries and their "
+    "supporting directory structure will be written.\n"
+    "REBUILD_REGISTRIES informs pluginify whether or not to rebuild registries at "
+    "runtime if a plugin cannot be located."
+)
+
+app.add_typer(
+    config_app,
+    name="config",
+    help=f"Configure pluginify.\n\n{config_variable_help}",
+)
+config_app.add_typer(
+    config_set_app,
+    name="set",
+    help=f"Set pluginify configuration variables.\n\n{config_variable_help}",
+)
 
 
 @app.command()
@@ -177,7 +203,37 @@ def create(
     packages: Optional[List[str]] = None,
     save_type: Literal["json", "yaml"] = "json",
 ):
-    """Create plugin registry files for one or more packages under a given namespace.
+    """Create plugin registries.
+
+    Plugin registries are low-level files which contain dictionaries of metadata for all
+    plugins implemented in one or more packages registered under a common namespace.
+
+    Pluginify creates and makes use of these registry files to properly load and
+    instantiate your plugins.
+
+    Examples
+    --------
+    Namespace: packageX.plugin_packages
+    Directory structure:
+
+        packageX/
+            plugins/
+            interfaces/
+            utils/
+            registered_plugins.json [will create]
+        packageY/
+            plugins/
+            registered_plugins.json [will create]
+
+    JSON registry files are faster to load and are used by default. YAML
+    extensions are also supported for easier viewing.
+
+    CLI examples
+    ------------
+    pluginify create
+    pluginify create -n packageX.plugin_packages
+    pluginify create -s yaml
+    pluginify create -n packageX.plugin_packages -p packageY
 
     Parameters
     ----------
@@ -199,7 +255,35 @@ def delete(
     namespace: str = NAMESPACE,
     packages: Optional[List[str]] = None,
 ):
-    """Delete plugin registry files for one or more packages under a given namespace.
+    """Delete plugin registries.
+
+    Plugin registries are low-level files which contain dictionaries of metadata for all
+    plugins implemented in one or more packages registered under a common namespace.
+
+    By default, this command will delete every .json and .yaml instance of registry
+    files for every package registered under a given namespace. If you only want to
+    delete registry files from a subset of packages, use the '-p' flag to specify those
+    packages.
+
+    Examples
+    --------
+    Namespace: packageX.plugin_packages
+    Directory structure:
+
+        packageX/
+            plugins/
+            interfaces/
+            utils/
+            registered_plugins.json [will delete]
+        packageY/
+            plugins/
+            registered_plugins.json [will delete]
+
+    CLI examples
+    ------------
+    pluginify delete
+    pluginify delete -n packageX.plugin_packages
+    pluginify delete -n packageX.plugin_packages -p packageY
 
     Parameters
     ----------
@@ -213,7 +297,7 @@ def delete(
     plugin_registry.delete_registries(packages=packages)
 
 
-@config_app.command("set-rebuild-registries")
+@config_set_app.command("rebuild-registries")
 def set_rebuild_registries(rebuild_registries: bool):
     """Set pluginify's REBUILD_REGISTRIES config variable.
 
@@ -226,7 +310,7 @@ def set_rebuild_registries(rebuild_registries: bool):
     update_existing_fields({"REBUILD_REGISTRIES": rebuild_registries})
 
 
-@config_app.command("set-namespace")
+@config_set_app.command("namespace")
 def set_namespace(namespace: str):
     """Set pluginify's NAMESPACE config variable.
 
@@ -239,7 +323,7 @@ def set_namespace(namespace: str):
     update_existing_fields({"NAMESPACE": namespace})
 
 
-@config_app.command("set-registry-directory")
+@config_set_app.command("registry-directory")
 def set_registry_directory(registry_directory: Path):
     """Set pluginify's REGISTRY_DIRECTORY config variable.
 

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/pluginify/create_plugin_registries.py

@@ -27,6 +27,7 @@ from os.path import (
     split,
     splitext,
 )
+from pathlib import Path
 import re
 import warnings
 
@@ -481,6 +482,13 @@ def parse_plugin_paths(plugin_paths, package, package_dir, plugins, namespace):
     for plugin_type in plugin_paths:
         # Loop through each file of the current plugin type.
         for filepath in plugin_paths[plugin_type]:
+            # If any 'part' of the full filepath starts with a '.' (dot) directory or
+            # file, do not use this filepath. Just continue to the next filepath
+            # provided. Resolving path to prevent false-positives on "." or ".."
+            # paths for relative paths as an edge case.
+            if any(part.startswith(".") for part in Path(filepath).resolve().parts):
+                continue
+
             filepath = str(filepath)
             # Path relative to the package directory
             relpath = os_relpath(filepath, start=package_dir)

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/pluginify/plugin_registry.py

@@ -36,6 +36,34 @@ from pluginify.utils import merge_nested_dicts
 LOG = logging.getLogger(__name__)
 
 
+def env_constructor(loader, node):
+    """YAML constructor for the ``!ENV`` tag that expands environment variables.
+
+    This function allows YAML files to include environment variables using
+    the ``!ENV`` tag. The scalar value associated with the tag is read and
+    any environment variables within the string (e.g. ``${VAR_NAME}``) are
+    expanded using :func:`os.path.expandvars`.
+
+    Parameters
+    ----------
+    loader : yaml.Loader
+        The YAML loader instance currently parsing the document.
+    node : yaml.Node
+        The YAML node containing the scalar value associated with the ``!ENV`` tag.
+
+    Returns
+    -------
+    str
+        The scalar value with any environment variables expanded using the
+        current process environment.
+    """
+    value = loader.construct_scalar(node)
+    return os.path.expandvars(value)
+
+
+yaml.SafeLoader.add_constructor("!ENV", env_constructor)
+
+
 class PluginRegistry:
     """Plugin Registry class definition.
 
@@ -372,7 +400,7 @@ class PluginRegistry:
 
         return metadata
 
-    def load_plugin(self, data: dict) -> BaseModel:
+    def load_plugin(self, data: dict, _expand: bool = False) -> BaseModel:
         """
         Dynamically load and validate pydantic models based on apiVersion and interface.
 
@@ -387,6 +415,10 @@ class PluginRegistry:
             Dictionary representing a plugin definition. Must include the `interface`
             field. May optionally include `apiVersion`. If not present, "pluginify/v1"
             is assumed.
+        _expand : private bool (default=False)
+            If true, fully expand the workflow plugin in place. Otherwise, load as is
+            done usually. This should only be used for the
+            'geoips expand <workflow>' command.
 
         Returns
         -------
@@ -400,7 +432,9 @@ class PluginRegistry:
         ImportError
             If the specified module for the given model version cannot be imported.
         """
-        api_version = data.get("apiVersion", "pluginify/v1")
+        # Make this GeoIPS for now, change later once apiVersion is set on all yaml
+        # plugins.
+        api_version = data.get("apiVersion", "geoips/v1")
 
         # Split "package_name/model_version"
         # Use package_name to select the appropriate package to search for the api.
@@ -418,9 +452,15 @@ class PluginRegistry:
 
         # Construct module path and import
         try:
-            module = import_module(
-                f"{package_name}.pydantic_models.{model_version}.{interface}"
-            )
+            if interface == "product_defaults":
+                # product_defaults model defined in products pydantic module
+                module = import_module(
+                    f"{package_name}.pydantic_models.{model_version}.products"
+                )
+            else:
+                module = import_module(
+                    f"{package_name}.pydantic_models.{model_version}.{interface}"
+                )
         except ImportError as e:
             raise ImportError(
                 f"Could not import models from '{api_version}': {e}"
@@ -431,15 +471,20 @@ class PluginRegistry:
 
         try:
             model_class = getattr(module, model_name)
-            print("model class \t", model_class)
         except AttributeError as e:
             raise ValueError(
                 f"Model '{model_name}' not found in '{api_version}'"
             ) from e
 
-        return model_class.model_validate(data)
+        if _expand:
+            # Only applies to workflow plugins
+            return model_class.model_validate(data, context={"expand": True})
 
-    def get_yaml_plugin(self, interface_obj, name, rebuild_registries=None):
+        return model_class(**data)
+
+    def get_yaml_plugin(
+        self, interface_obj, name, rebuild_registries=None, _expand=False
+    ):
         """Get a YAML plugin by its name.
 
         Parameters
@@ -456,7 +501,16 @@ class PluginRegistry:
               is true and get_plugin fails, rebuild the plugin registry, call then call
               get_plugin once more with rebuild_registries toggled off, so it only gets
               rebuilt once.
+        _expand: private bool (default=False)
+            - If true, fully expand the workflow plugin in place. Otherwise, load as is
+              done usually. This should only be used for the
+              'geoips expand <workflow>' command.
         """
+        if _expand and interface_obj.name != "workflows":
+            raise AssertionError(
+                "Error: you cannot set argument 'expand' to true unless you are "
+                "requesting a workflow plugin."
+            )
         try:
             registered_yaml_plugins = self.registered_plugins["yaml_based"]
         except KeyError:
@@ -562,7 +616,21 @@ class PluginRegistry:
         plugin["relpath"] = relpath
 
         if getattr(interface_obj, "use_pydantic", False):
-            return self.load_plugin(plugin).model_dump()
+
+            def remove_none(d: dict) -> dict:
+                """Recursively remove all keys with value None from a dictionary."""
+                if not isinstance(d, dict):
+                    return d
+                return {k: remove_none(v) for k, v in d.items() if v is not None}
+
+            validated = self.load_plugin(plugin, _expand).model_dump()
+            validated = remove_none(validated)
+
+            if "package" not in validated or "relpath" not in validated:
+                validated["package"] = package
+                validated["relpath"] = relpath
+
+            return interface_obj._plugin_yaml_to_obj(name, validated)
         else:
             validated = interface_obj.validator.validate(plugin)
             return interface_obj._plugin_yaml_to_obj(name, validated)

pluginify-0.1.0.post11.dev0/pluginify/utils/validators.py

@@ -0,0 +1,183 @@
+"""Pluginify validators module.
+
+Currently only implements a PluginRegistryValidator class.
+"""
+
+from importlib import metadata, import_module
+import json
+from pprint import pformat
+
+import pytest
+
+from pluginify.errors import PluginRegistryError
+from pluginify.plugin_registry import PluginRegistry
+
+
+class PluginRegistryValidator(PluginRegistry):
+    """Subclass of PluginRegistry which adds functionality for unit testing."""
+
+    def __init__(self, namespace, fpaths=None):
+        """Initialize TestPluginRegistry Class."""
+        self.namespace = namespace
+        super().__init__(self.namespace, _test_registry_files=fpaths)
+
+    def validate_plugin_types_exist(self, reg_dict, reg_path):
+        """Test that all top level plugin types exist in each registry file."""
+        expected_plugin_types = ["yaml_based", "class_based", "text_based"]
+        for p_type in expected_plugin_types:
+            if p_type not in reg_dict:
+                error_str = f"Expected plugin type '{p_type}' to be in the registry but"
+                error_str += f" wasn't. This was in file '{reg_path}'."
+                raise PluginRegistryError(error_str)
+
+    def validate_all_registries(self):
+        """Validate all registries in the current installation.
+
+        This should be run during testing, but not at runtime.
+        Ensure we do not fail catastrophically for a single bad plugin
+        at runtime, so test up front to test validity.
+        """
+        for reg_path in self.registry_files:
+            pkg_plugins = json.load(open(reg_path, "r"))
+            self.validate_registry(pkg_plugins, reg_path)
+
+    def validate_registry(self, current_registry, fpath):
+        """Test all plugins found in registered plugins for their validity."""
+        try:
+            self.validate_plugin_types_exist(current_registry, fpath)
+        except PluginRegistryError as e:
+            # xfail if this is a test, otherwise just raise PluginRegistryError
+            if self._is_test:
+                pytest.xfail(str(e))
+            else:
+                raise PluginRegistryError(e)
+        try:
+            self.validate_registry_interfaces(current_registry)
+        except PluginRegistryError as e:
+            # xfail if this is a test, otherwise just raise PluginRegistryError
+            if self._is_test:
+                pytest.xfail(str(e))
+            else:
+                raise PluginRegistryError(e)
+        for plugin_type in current_registry:
+            for interface in current_registry[plugin_type]:
+                for plugin in current_registry[plugin_type][interface]:
+                    try:
+                        if interface == "products":
+                            for subplg in current_registry[plugin_type][interface][
+                                plugin
+                            ]:
+                                self.validate_plugin_attrs(
+                                    plugin_type,
+                                    interface,
+                                    (plugin, subplg),
+                                    current_registry[plugin_type][interface][plugin][
+                                        subplg
+                                    ],
+                                )
+                        elif plugin_type != "text_based":
+                            self.validate_plugin_attrs(
+                                plugin_type,
+                                interface,
+                                plugin,
+                                current_registry[plugin_type][interface][plugin],
+                            )
+                    except PluginRegistryError as e:
+                        # xfail if this is a test,
+                        # otherwise just raise PluginRegistryError
+                        if self._is_test:
+                            pytest.xfail(str(e))
+                        else:
+                            raise PluginRegistryError(e)
+
+    def validate_plugin_attrs(self, plugin_type, interface, name, plugin):
+        """Test non-product plugin for all required attributes."""
+        missing = []
+        if plugin_type == "yaml_based" and interface != "products":
+            attrs = [
+                "docstring",
+                "family",
+                "interface",
+                "package",
+                "plugin_type",
+                "relpath",
+            ]
+        elif plugin_type == "yaml_based":
+            attrs = [
+                "docstring",
+                "family",
+                "interface",
+                "package",
+                "plugin_type",
+                "product_defaults",
+                "source_names",
+                "relpath",
+            ]
+        else:
+            attrs = [
+                "docstring",
+                "family",
+                "interface",
+                "package",
+                "plugin_type",
+                "signature",
+                "relpath",
+            ]
+        for attr in attrs:
+            try:
+                plugin[attr]
+            except KeyError:
+                missing.append(attr)
+        if missing:
+            raise PluginRegistryError(
+                f"Plugin '{name}' is missing the following required "
+                f"top-level properties: '{missing}'"
+            )
+
+    def validate_registry_interfaces(self, current_registry):
+        """Test Plugin Registry interfaces validity."""
+        yaml_interfaces = []
+        class_interfaces = []
+
+        # NOTE: all <pkg>/interfaces/__init__.py files MUST
+        # contain a "class_based_interfaces" list and a
+        # "yaml_based_interfaces" list - this is how we
+        # identify the valid interface names.
+        # We must avoid actually importing the interfaces within
+        # the pluginify repo - or we will end up with a circular import
+        # due to BaseInterface.
+        for pkg in metadata.entry_points(group=self.namespace):
+            try:
+                mod = import_module(f"{pkg.value}.interfaces")
+            except ModuleNotFoundError as resp:
+                if f"No module named '{pkg.value}.interfaces'" in str(resp):
+                    continue
+                else:
+                    raise ModuleNotFoundError(resp)
+            class_interfaces += mod.class_based_interfaces
+            yaml_interfaces += mod.yaml_based_interfaces
+
+        bad_interfaces = []
+        for plugin_type in ["class_based", "yaml_based"]:
+            for interface in current_registry[plugin_type]:
+                if (
+                    interface not in class_interfaces
+                    and interface not in yaml_interfaces
+                ):
+                    error_str = f"\nPlugin type '{plugin_type}' does not allow "
+                    error_str += f"interface '{interface}'.\n"
+                    error_str += "\nValid interfaces: "
+                    if plugin_type == "class_based":
+                        interface_list = class_interfaces
+                    else:
+                        interface_list = yaml_interfaces
+                    error_str += f"\n{interface_list}\n"
+                    error_str += "\nPlease update the following plugins "
+                    error_str += "to use a valid interface:\n"
+                    error_str += pformat(current_registry[plugin_type][interface])
+                    bad_interfaces.append(error_str)
+        if bad_interfaces:
+            error_str = "The following interfaces were not valid:\n"
+            for error in bad_interfaces:
+                error_str += error
+            raise PluginRegistryError(error_str)

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pluginify" # package available at the root of the project
-version = "0.0.0.post1.dev0"
+version = "0.1.0.post11.dev0"
 description = "Pluginify package"
 authors = ["Evan Rose", "evrose54@colostate.edu"]
 readme = "README.md"
@@ -38,7 +38,7 @@ requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
 build-backend = "poetry_dynamic_versioning.backend"                          # object used to perform the build process
 
 [tool.poetry.dependencies] # Include any python dependencies here
-python = ">=3.11.0,<3.13.0"    # mandatory to declare the required python version
+python = ">=3.11.0"    # mandatory to declare the required python version
 pydantic = ">=2.10.0"  # Data validation using Python type hints
 pyyaml = "*"           # Base requirement
 jsonschema = ">4.18.0" # Provides validation for YAML plugins

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0.post11.dev0}/tests/unit_tests/plugin_registries/test_plugin_registries.py

@@ -4,19 +4,16 @@
 """TestPluginRegistry Class used for Unit Testing the Plugin Registries."""
 
 from glob import glob
-from importlib import import_module, metadata
 import logging
 from os.path import basename, splitext
-from pprint import pformat
 
 import pytest
-import json
 import yaml
 
 from pluginify.errors import PluginError, PluginRegistryError
 from pluginify.interfaces import configs
 from pluginify.interfaces import data_modifiers
-from pluginify.plugin_registry import PluginRegistry
+from pluginify.utils.validators import PluginRegistryValidator
 
 LOG = logging.getLogger(__name__)
 
@@ -28,175 +25,6 @@ class FakeInterface:
     name = "fake_interface"
 
 
-class PluginRegistryValidator(PluginRegistry):
-    """Subclass of PluginRegistry which adds functionality for unit testing."""
-
-    def __init__(self, fpaths=None):
-        """Initialize TestPluginRegistry Class."""
-        super().__init__("pluginify.plugin_packages", _test_registry_files=fpaths)
-
-    def validate_plugin_types_exist(self, reg_dict, reg_path):
-        """Test that all top level plugin types exist in each registry file."""
-        expected_plugin_types = ["yaml_based", "class_based", "text_based"]
-        for p_type in expected_plugin_types:
-            if p_type not in reg_dict:
-                error_str = f"Expected plugin type '{p_type}' to be in the registry but"
-                error_str += f" wasn't. This was in file '{reg_path}'."
-                raise PluginRegistryError(error_str)
-
-    def validate_all_registries(self):
-        """Validate all registries in the current installation.
-
-        This should be run during testing, but not at runtime.
-        Ensure we do not fail catastrophically for a single bad plugin
-        at runtime, so test up front to test validity.
-        """
-        for reg_path in self.registry_files:
-            pkg_plugins = json.load(open(reg_path, "r"))
-            self.validate_registry(pkg_plugins, reg_path)
-
-    def validate_registry(self, current_registry, fpath):
-        """Test all plugins found in registered plugins for their validity."""
-        try:
-            self.validate_plugin_types_exist(current_registry, fpath)
-        except PluginRegistryError as e:
-            # xfail if this is a test, otherwise just raise PluginRegistryError
-            if self._is_test:
-                pytest.xfail(str(e))
-            else:
-                raise PluginRegistryError(e)
-        try:
-            self.validate_registry_interfaces(current_registry)
-        except PluginRegistryError as e:
-            # xfail if this is a test, otherwise just raise PluginRegistryError
-            if self._is_test:
-                pytest.xfail(str(e))
-            else:
-                raise PluginRegistryError(e)
-        for plugin_type in current_registry:
-            for interface in current_registry[plugin_type]:
-                for plugin in current_registry[plugin_type][interface]:
-                    try:
-                        if interface == "products":
-                            for subplg in current_registry[plugin_type][interface][
-                                plugin
-                            ]:
-                                self.validate_plugin_attrs(
-                                    plugin_type,
-                                    interface,
-                                    (plugin, subplg),
-                                    current_registry[plugin_type][interface][plugin][
-                                        subplg
-                                    ],
-                                )
-                        elif plugin_type != "text_based":
-                            self.validate_plugin_attrs(
-                                plugin_type,
-                                interface,
-                                plugin,
-                                current_registry[plugin_type][interface][plugin],
-                            )
-                    except PluginRegistryError as e:
-                        # xfail if this is a test,
-                        # otherwise just raise PluginRegistryError
-                        if self._is_test:
-                            pytest.xfail(str(e))
-                        else:
-                            raise PluginRegistryError(e)
-
-    def validate_plugin_attrs(self, plugin_type, interface, name, plugin):
-        """Test non-product plugin for all required attributes."""
-        missing = []
-        if plugin_type == "yaml_based" and interface != "products":
-            attrs = [
-                "docstring",
-                "family",
-                "interface",
-                "package",
-                "plugin_type",
-                "relpath",
-            ]
-        elif plugin_type == "yaml_based":
-            attrs = [
-                "docstring",
-                "family",
-                "interface",
-                "package",
-                "plugin_type",
-                "product_defaults",
-                "source_names",
-                "relpath",
-            ]
-        else:
-            attrs = [
-                "docstring",
-                "family",
-                "interface",
-                "package",
-                "plugin_type",
-                "signature",
-                "relpath",
-            ]
-        for attr in attrs:
-            try:
-                plugin[attr]
-            except KeyError:
-                missing.append(attr)
-        if missing:
-            raise PluginRegistryError(
-                f"Plugin '{name}' is missing the following required "
-                f"top-level properties: '{missing}'"
-            )
-
-    def validate_registry_interfaces(self, current_registry):
-        """Test Plugin Registry interfaces validity."""
-        yaml_interfaces = []
-        class_interfaces = []
-
-        # NOTE: all <pkg>/interfaces/__init__.py files MUST
-        # contain a "class_based_interfaces" list and a
-        # "yaml_based_interfaces" list - this is how we
-        # identify the valid interface names.
-        # We must avoid actually importing the interfaces within
-        # the pluginify repo - or we will end up with a circular import
-        # due to BaseInterface.
-        for pkg in metadata.entry_points(group="pluginify.plugin_packages"):
-            try:
-                mod = import_module(f"{pkg.value}.interfaces")
-            except ModuleNotFoundError as resp:
-                if f"No module named '{pkg.value}.interfaces'" in str(resp):
-                    continue
-                else:
-                    raise ModuleNotFoundError(resp)
-            class_interfaces += mod.class_based_interfaces
-            yaml_interfaces += mod.yaml_based_interfaces
-
-        bad_interfaces = []
-        for plugin_type in ["class_based", "yaml_based"]:
-            for interface in current_registry[plugin_type]:
-                if (
-                    interface not in class_interfaces
-                    and interface not in yaml_interfaces
-                ):
-                    error_str = f"\nPlugin type '{plugin_type}' does not allow "
-                    error_str += f"interface '{interface}'.\n"
-                    error_str += "\nValid interfaces: "
-                    if plugin_type == "class_based":
-                        interface_list = class_interfaces
-                    else:
-                        interface_list = yaml_interfaces
-                    error_str += f"\n{interface_list}\n"
-                    error_str += "\nPlease update the following plugins "
-                    error_str += "to use a valid interface:\n"
-                    error_str += pformat(current_registry[plugin_type][interface])
-                    bad_interfaces.append(error_str)
-        if bad_interfaces:
-            error_str = "The following interfaces were not valid:\n"
-            for error in bad_interfaces:
-                error_str += error
-            raise PluginRegistryError(error_str)
-
-
 class TestPluginRegistry:
     """
     Pytest-based Unit Test for the PluginRegistry Class.
@@ -212,12 +40,16 @@ class TestPluginRegistry:
     )
 
     # pr_validator uses test registry files for most tests
-    pr_validator = PluginRegistryValidator(fpaths=default_fpaths)
+    pr_validator = PluginRegistryValidator(
+        namespace="pluginify.plugin_packages", fpaths=default_fpaths
+    )
     # real reg validator is responsible for testing deleting and building of registries
     # based on whether or not we want that to occur:
     # I.e. whether or not config.REBUILD_REGISTRIES is set to True or
     # False
-    real_reg_validator = PluginRegistryValidator(fpaths=None)
+    real_reg_validator = PluginRegistryValidator(
+        namespace="pluginify.plugin_packages", fpaths=None
+    )
 
     # Couldn't implement this class via inheritance because PyTest Raised this error:
     # PytestCollectionWarning: cannot collect test class 'TestPluginRegistry' because