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

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0}/.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}/PKG-INFO

@@ -1,15 +1,17 @@
 Metadata-Version: 2.4
 Name: pluginify
-Version: 0.0.0.post1.dev0
+Version: 0.1.0
 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}/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/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/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/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}/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"
+__version_tuple__ = (0, 1, 0)

{pluginify-0.0.0.post1.dev0 → pluginify-0.1.0}/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.1.0/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}/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"
 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}/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