pyrig-runtime 2.2.1__tar.gz → 2.3.0__tar.gz

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrig-runtime
-Version: 2.2.1
+Version: 2.3.0
 Summary: Runtime dependency and library for projects built with pyrig.
 Keywords: pyrig
 Author: Winipedia

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyrig-runtime"
-version = "2.2.1"
+version = "2.3.0"
 description = "Runtime dependency and library for projects built with pyrig."
 readme = "README.md"
 requires-python = ">=3.12"

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/src/pyrig_runtime/core/dependencies/discovery.py

@@ -21,34 +21,34 @@ logger = logging.getLogger(__name__)
 
 def discover_subclasses_across_dependencies[T](
     cls: type[T],
-    package: ModuleType,
+    module: ModuleType,
 ) -> Iterator[type[T]]:
-    """Yield subclasses of `cls` found in `package` and in dependent packages.
+    """Yield subclasses of `cls` found in `module` and in dependent packages.
 
     Args:
         cls: Base class whose subclasses should be discovered.
-        package: Package to search first, also used to determine which root
+        module: Module to search first, also used to determine which root
             package to scan for dependents.
 
     Yields:
-        Subclass types of `cls`, with `package` searched first, then
+        Subclass types of `cls`, with `module` searched first, then
         dependent packages in dependency order.
     """
     logger.debug(
         "Discovering subclasses of %s from modules in packages depending on %s",
         cls.__name__,
-        package.__name__,
+        module.__name__,
     )
 
     return (
         subclass
-        for pkg in chain(
-            (package,),
-            discover_equivalent_modules_across_dependents(module=package),
+        for mod in chain(
+            (module,),
+            discover_equivalent_modules_across_dependents(module=module),
         )
         for subclass in discover_subclasses_across_package(
             cls,
-            package=pkg,
+            module=mod,
         )
     )
 

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/src/pyrig_runtime/core/dependencies/subclass.py

@@ -63,10 +63,11 @@ class DependencySubclassMeta(ABCMeta):
 class DependencySubclass(metaclass=DependencySubclassMeta):
     """Abstract base enabling plugin-style subclass discovery across installed packages.
 
-    Subclasses declare a sub-package scope by overriding the discovery hook,
+    Subclasses declare a discovery scope by overriding the discovery hook,
     and the base class automatically finds all subclass implementations defined
-    in that sub-package across every installed package that depends on the root
-    package. No explicit registration is required.
+    in that scope across every installed package that depends on the root
+    package. The scope may be a single module or a whole sub-package. No
+    explicit registration is required.
     """
 
     def __str__(self) -> str:
@@ -75,17 +76,19 @@ class DependencySubclass(metaclass=DependencySubclassMeta):
 
     @classmethod
     @abstractmethod
-    def dependency_package(cls) -> ModuleType:
-        """Return the sub-package where this class's implementations are defined.
+    def discovery_module(cls) -> ModuleType:
+        """Return the module or package where this class's implementations are defined.
 
-        Every concrete subclass must override this to return the sub-package
-        module that contains its own implementation classes. The base class uses
-        the returned module to scope cross-package subclass discovery.
+        Every concrete subclass must override this to return the module or
+        sub-package that contains its own implementation classes. When a
+        package is returned it is searched recursively; when a plain module is
+        returned only that module is searched. The base class uses the returned
+        module to scope cross-package subclass discovery.
 
         The base implementation returns `pyrig_runtime.rig`.
 
         Returns:
-            The sub-package module to search for concrete implementations of
+            The module or package to search for concrete implementations of
             this class.
         """
         return rig
@@ -158,7 +161,7 @@ Found subclasses:
         return discard_parent_classes(
             discover_subclasses_across_dependencies(
                 cls,
-                package=cls.dependency_package(),
+                module=cls.discovery_module(),
             )
         )
 

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/src/pyrig_runtime/core/introspection/packages.py

@@ -1,4 +1,4 @@
-"""Subclass discovery scoped to a package's full module hierarchy."""
+"""Subclass discovery scoped to a single module or a package's module hierarchy."""
 
 from collections.abc import Iterator
 from functools import cache
@@ -10,31 +10,33 @@ from pyrig_runtime.core.introspection.modules import iter_modules
 
 def discover_subclasses_across_package[T](
     cls: type[T],
-    package: ModuleType,
+    module: ModuleType,
 ) -> set[type[T]]:
-    """Discover all subclasses of `cls` defined within a package.
+    """Discover all subclasses of `cls` defined within a module or package.
 
-    The package is scanned recursively, so subclasses are found in its
-    sub-modules at any nesting depth, including ones not yet imported when this
-    is called. Only subclasses whose defining module is a proper sub-module of
-    `package` are returned; a class defined directly in the package's own
-    `__init__` module is not discovered, so implementations belong in
-    sub-modules rather than the package `__init__`.
+    When `module` is a package, it is scanned recursively, so subclasses are
+    found in its sub-modules at any nesting depth, including ones not yet
+    imported when this is called. When `module` is a plain module, only
+    subclasses defined directly in that module are returned.
+
+    A subclass matches when its defining module is `module` itself or a
+    sub-module of it.
 
     Args:
         cls: Base class whose subclasses should be discovered.
-        package: Package to scope discovery to.
+        module: Module or package to scope discovery to.
 
     Returns:
         Set of all transitive subclass types of `cls` defined within
-        `package`, excluding `cls` itself.
+        `module`, excluding `cls` itself.
     """
-    register_package_modules(package)
+    if is_package(module):
+        register_package_modules(module)
     subclasses = discover_subclasses(cls)
     return {
         subclass
         for subclass in subclasses
-        if subclass.__module__.startswith(f"{package.__name__}.")
+        if subclass.__module__.startswith(module.__name__)
     }
 
 
@@ -71,3 +73,15 @@ def walk_package(package: ModuleType) -> Iterator[tuple[ModuleType, bool]]:
             yield from walk_package(module)
         else:
             yield module, False
+
+
+def is_package(module: ModuleType) -> bool:
+    """Return True if `module` is a package, False otherwise.
+
+    Args:
+        module: Module to check.
+
+    Returns:
+        True if `module` is a package, False otherwise.
+    """
+    return hasattr(module, "__path__")

{pyrig_runtime-2.2.1/src/pyrig_runtime/rig/cli → pyrig_runtime-2.3.0/src/pyrig_runtime/rig}/cli/cli.py

@@ -2,6 +2,7 @@
 
 import logging
 import sys
+from importlib import import_module
 from itertools import chain
 from pathlib import Path
 from types import ModuleType
@@ -22,7 +23,7 @@ from pyrig_runtime.core.strings import (
     kebab_to_snake_case,
     snake_to_kebab_case,
 )
-from pyrig_runtime.rig.cli import cli, shared_subcommands, subcommands
+from pyrig_runtime.rig.cli import shared_subcommands, subcommands
 
 
 class CLI(DependencySubclass):
@@ -34,9 +35,9 @@ class CLI(DependencySubclass):
     """
 
     @classmethod
-    def dependency_package(cls) -> ModuleType:
-        """Return the `pyrig_runtime.rig.cli.cli` package module."""
-        return cli
+    def discovery_module(cls) -> ModuleType:
+        """Return the `pyrig_runtime.rig.cli.cli` module."""
+        return import_module(CLI.__module__)
 
     def run(self) -> None:
         """Build and invoke the Typer application."""

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/src/pyrig_runtime/rig/cli/commands/version.py

@@ -4,7 +4,7 @@ from importlib.metadata import version
 
 import typer
 
-from pyrig_runtime.rig.cli.cli.cli import CLI
+from pyrig_runtime.rig.cli.cli import CLI
 
 
 def project_version() -> None:

{pyrig_runtime-2.2.1 → pyrig_runtime-2.3.0}/src/pyrig_runtime/rig/cli/main.py

@@ -1,6 +1,6 @@
 """Console-script entry point for pyrig-runtime-based projects."""
 
-from pyrig_runtime.rig.cli.cli.cli import CLI
+from pyrig_runtime.rig.cli.cli import CLI
 
 
 def main() -> None:

pyrig_runtime-2.2.1/src/pyrig_runtime/rig/cli/cli/__init__.py

@@ -1 +0,0 @@
-"""Extensible CLI builder for pyrig-runtime-based projects."""