pyrig-runtime 0.1.0__tar.gz

pyrig_runtime-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Winipedia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrig_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: pyrig-runtime
+Version: 0.1.0
+Summary: Add your description here
+Keywords: pyrig
+Author: Winipedia
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Dist: typer>=0.26.7
+Maintainer: Winipedia
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/Winipedia/pyrig-runtime
+Project-URL: Documentation, https://Winipedia.github.io/pyrig-runtime
+Project-URL: Source, https://github.com/Winipedia/pyrig-runtime
+Project-URL: Issues, https://github.com/Winipedia/pyrig-runtime/issues
+Project-URL: Changelog, https://github.com/Winipedia/pyrig-runtime/releases
+Description-Content-Type: text/markdown
+
+# pyrig-runtime
+
+<!-- ci/cd -->
+[![CI](https://img.shields.io/github/actions/workflow/status/Winipedia/pyrig-runtime/health_check.yml?label=CI&logo=github)](https://github.com/Winipedia/pyrig-runtime/actions/workflows/health_check.yml)
+[![CD](https://img.shields.io/github/actions/workflow/status/Winipedia/pyrig-runtime/deploy.yml?label=CD&logo=github)](https://github.com/Winipedia/pyrig-runtime/actions/workflows/deploy.yml)
+<!-- testing -->
+[![CoverageTester](https://codecov.io/gh/Winipedia/pyrig-runtime/branch/main/graph/badge.svg)](https://codecov.io/gh/Winipedia/pyrig-runtime)
+[![ProjectTester](https://img.shields.io/badge/tested%20with-pytest-46a2f1.svg?logo=pytest)](https://pytest.org)
+<!-- code-quality -->
+[![DependencyAuditor](https://img.shields.io/badge/security-pip--audit-blue?logo=python)](https://github.com/pypa/pip-audit)
+[![DependencyChecker](https://img.shields.io/badge/dependencies-deptry-blue)](https://github.com/osprey-oss/deptry)
+[![MarkdownLinter](https://img.shields.io/badge/markdown-rumdl-darkgreen)](https://github.com/rvben/rumdl)
+[![PythonLinter](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![SecurityChecker](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![SpellChecker](https://img.shields.io/badge/spell--check-typos-blue)](https://github.com/crate-ci/typos)
+[![TypeChecker](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+[![VersionControlHookManager](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/j178/prek/master/docs/assets/badge-v0.json)](https://github.com/j178/prek)
+<!-- tooling -->
+[![PackageManager](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Pyrigger](https://img.shields.io/badge/built%20with-pyrig-3776AB?logo=buildkite&logoColor=black)](https://github.com/Winipedia/pyrig)
+[![RemoteVersionController](https://img.shields.io/github/stars/Winipedia/pyrig-runtime?style=social)](https://github.com/Winipedia/pyrig-runtime)
+[![VersionController](https://img.shields.io/badge/Git-F05032?logo=git&logoColor=white)](https://git-scm.com)
+<!-- project-info -->
+[![DocsBuilder](https://img.shields.io/badge/MkDocs-Documentation-326CE5?logo=mkdocs&logoColor=white)](https://Winipedia.github.io/pyrig-runtime)
+[![PackageIndex](https://img.shields.io/pypi/v/pyrig-runtime?logo=pypi&logoColor=white)](https://pypi.org/project/pyrig-runtime)
+[![ProgrammingLanguage](https://img.shields.io/pypi/pyversions/pyrig-runtime)](https://www.python.org)
+[![License](https://img.shields.io/github/license/Winipedia/pyrig-runtime)](https://github.com/Winipedia/pyrig-runtime/blob/main/LICENSE)
+
+---
+
+> Add your description here
+
+---

pyrig_runtime-0.1.0/README.md

@@ -0,0 +1,33 @@
+# pyrig-runtime
+
+<!-- ci/cd -->
+[![CI](https://img.shields.io/github/actions/workflow/status/Winipedia/pyrig-runtime/health_check.yml?label=CI&logo=github)](https://github.com/Winipedia/pyrig-runtime/actions/workflows/health_check.yml)
+[![CD](https://img.shields.io/github/actions/workflow/status/Winipedia/pyrig-runtime/deploy.yml?label=CD&logo=github)](https://github.com/Winipedia/pyrig-runtime/actions/workflows/deploy.yml)
+<!-- testing -->
+[![CoverageTester](https://codecov.io/gh/Winipedia/pyrig-runtime/branch/main/graph/badge.svg)](https://codecov.io/gh/Winipedia/pyrig-runtime)
+[![ProjectTester](https://img.shields.io/badge/tested%20with-pytest-46a2f1.svg?logo=pytest)](https://pytest.org)
+<!-- code-quality -->
+[![DependencyAuditor](https://img.shields.io/badge/security-pip--audit-blue?logo=python)](https://github.com/pypa/pip-audit)
+[![DependencyChecker](https://img.shields.io/badge/dependencies-deptry-blue)](https://github.com/osprey-oss/deptry)
+[![MarkdownLinter](https://img.shields.io/badge/markdown-rumdl-darkgreen)](https://github.com/rvben/rumdl)
+[![PythonLinter](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![SecurityChecker](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![SpellChecker](https://img.shields.io/badge/spell--check-typos-blue)](https://github.com/crate-ci/typos)
+[![TypeChecker](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
+[![VersionControlHookManager](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/j178/prek/master/docs/assets/badge-v0.json)](https://github.com/j178/prek)
+<!-- tooling -->
+[![PackageManager](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Pyrigger](https://img.shields.io/badge/built%20with-pyrig-3776AB?logo=buildkite&logoColor=black)](https://github.com/Winipedia/pyrig)
+[![RemoteVersionController](https://img.shields.io/github/stars/Winipedia/pyrig-runtime?style=social)](https://github.com/Winipedia/pyrig-runtime)
+[![VersionController](https://img.shields.io/badge/Git-F05032?logo=git&logoColor=white)](https://git-scm.com)
+<!-- project-info -->
+[![DocsBuilder](https://img.shields.io/badge/MkDocs-Documentation-326CE5?logo=mkdocs&logoColor=white)](https://Winipedia.github.io/pyrig-runtime)
+[![PackageIndex](https://img.shields.io/pypi/v/pyrig-runtime?logo=pypi&logoColor=white)](https://pypi.org/project/pyrig-runtime)
+[![ProgrammingLanguage](https://img.shields.io/pypi/pyversions/pyrig-runtime)](https://www.python.org)
+[![License](https://img.shields.io/github/license/Winipedia/pyrig-runtime)](https://github.com/Winipedia/pyrig-runtime/blob/main/LICENSE)
+
+---
+
+> Add your description here
+
+---

pyrig_runtime-0.1.0/pyproject.toml

@@ -0,0 +1,113 @@
+[project]
+name = "pyrig-runtime"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "typer>=0.26.7",
+]
+license = "MIT"
+license-files = [
+    "LICENSE",
+]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+keywords = [
+    "pyrig",
+]
+
+[[project.authors]]
+name = "Winipedia"
+
+[[project.maintainers]]
+name = "Winipedia"
+
+[project.urls]
+Homepage = "https://github.com/Winipedia/pyrig-runtime"
+Documentation = "https://Winipedia.github.io/pyrig-runtime"
+Source = "https://github.com/Winipedia/pyrig-runtime"
+Issues = "https://github.com/Winipedia/pyrig-runtime/issues"
+Changelog = "https://github.com/Winipedia/pyrig-runtime/releases"
+
+[project.scripts]
+pyrig-runtime = "pyrig.rig.cli.main:main"
+
+[dependency-groups]
+dev = [
+    "bandit>=1.9.4",
+    "deptry>=0.25.1",
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.6",
+    "mkdocs-mermaid2-plugin>=1.2.3",
+    "mkdocstrings[python]>=1.0.4",
+    "pip-audit>=2.10.1",
+    "prek>=0.4.5",
+    "pyrig>=15.23.0",
+    "pyrig-codecov>=1.10.0",
+    "pyrig-fixtures>=0.10.0",
+    "pyrig-pypi>=1.13.0",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.19",
+    "rumdl>=0.2.22",
+    "ty>=0.0.53",
+    "typos>=1.47.2",
+]
+
+[build-system]
+requires = [
+    "uv_build",
+]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+select = [
+    "ALL",
+]
+ignore = [
+    "COM812",
+    "ANN401",
+]
+fixable = [
+    "ALL",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"**/tests/**/*.py" = [
+    "S101",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ty.terminal]
+error-on-warning = true
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]
+addopts = "--cov=pyrig_runtime --cov-branch --cov-report=term-missing --cov-fail-under=100 --cov-report=xml"
+
+[tool.bandit.assert_used]
+skips = [
+    "*/tests/*.py",
+    "*/test_*/*.py",
+]
+
+[tool.deptry]
+root = "src"
+
+[tool.deptry.per_rule_ignores]
+DEP002 = [
+    "pyrig",
+]

pyrig_runtime-0.1.0/src/pyrig_runtime/__init__.py

@@ -0,0 +1 @@
+"""The top-level package for the project."""

pyrig_runtime-0.1.0/src/pyrig_runtime/core/__init__.py

@@ -0,0 +1 @@
+"""Package initialization."""

pyrig_runtime-0.1.0/src/pyrig_runtime/core/dependencies/__init__.py

@@ -0,0 +1,6 @@
+"""Introspection primitives for class, module, and package discovery.
+
+Provides the low-level building blocks that power pyrig's cross-package subclass
+discovery: walking package hierarchies, dynamically importing modules, filtering
+class collections, and locating equivalent module paths across dependent packages.
+"""

pyrig_runtime-0.1.0/src/pyrig_runtime/core/dependencies/discovery.py

@@ -0,0 +1,124 @@
+"""Subclass and module discovery scoped across installed package dependents."""
+
+import logging
+from collections.abc import Iterator
+from functools import cache
+from itertools import chain
+from types import ModuleType
+
+from pyrig_runtime.core.dependencies.graph import DependencyGraph
+from pyrig_runtime.core.introspection.modules import (
+    import_module_with_default,
+    import_modules,
+    root_module,
+)
+from pyrig_runtime.core.introspection.packages import (
+    discover_subclasses_across_package,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def discover_subclasses_across_dependencies[T](
+    cls: type[T],
+    package: ModuleType,
+) -> Iterator[type[T]]:
+    """Yield subclasses of `cls` found in `package` and in every dependent of its root.
+
+    Searches `package` itself first, then each installed package that depends on
+    `package`'s root package. In each dependent, the module path equivalent to
+    `package` is located (e.g., `pyrig.rig` becomes `<dep>.rig`), and every
+    subclass of `cls` defined there is collected.
+
+    Args:
+        cls: Base class whose subclasses should be discovered.
+        package: Module whose dotted path is replicated in each dependent package
+            to locate the modules to search. The root of this module determines
+            which installed packages are searched. For example, passing
+            `pyrig.rig` would search `<dep>.rig` in each dependent of `pyrig`.
+
+    Yields:
+        Subclass types of `cls` found across `package` and all dependent
+        packages, in dependency order (base package first, then dependents).
+    """
+    logger.debug(
+        "Discovering subclasses of %s from modules in packages depending on %s",
+        cls.__name__,
+        package.__name__,
+    )
+
+    return (
+        subclass
+        for pkg in chain(
+            (package,),
+            discover_equivalent_modules_across_dependents(module=package),
+        )
+        for subclass in discover_subclasses_across_package(
+            cls,
+            package=pkg,
+        )
+    )
+
+
+def discover_equivalent_modules_across_dependents(
+    module: ModuleType,
+) -> Iterator[ModuleType]:
+    """Yield the equivalent module from every package that depends on `module`'s root.
+
+    Given a module (e.g., `pyrig.rig.configs`), infers the root package
+    (e.g., `pyrig`), then constructs the equivalent dotted path in each package
+    that depends on that root (e.g., `myapp.rig.configs`), imports it if it
+    exists, and yields it.
+
+    The root package itself is not included in results — only its dependents are
+    iterated. The path transformation replaces the first occurrence of the root
+    package name in `module.__name__` with each dependent package's name, so a
+    consistent directory structure across the ecosystem is assumed.
+
+    Args:
+        module: Template module whose path pattern is replicated in each dependent
+            package (e.g., `pyrig.core` → `<pkg>.core` for every dependent).
+            The root of this module is used to discover dependent packages.
+
+    Yields:
+        Successfully imported module objects in dependency order. Packages whose
+        equivalent module path cannot be imported are silently skipped.
+    """
+    dependency = root_module(module)
+    logger.debug(
+        "Discovering modules equivalent to %s in packages depending on %s",
+        module.__name__,
+        dependency.__name__,
+    )
+
+    for package in deps_depending_on_dep(dependency):
+        package_module_name = module.__name__.replace(
+            dependency.__name__, package.__name__, 1
+        )
+        package_module = import_module_with_default(package_module_name)
+        if package_module is not None:
+            yield package_module
+
+
+@cache
+def deps_depending_on_dep(dependency: ModuleType) -> tuple[ModuleType, ...]:
+    """Return all installed packages that depend on `dependency`, as module objects.
+
+    Find every installed package that depends on `dependency` (directly or
+    transitively), import them, and return the result as a tuple in dependency
+    order. The result is cached per unique `dependency` argument.
+
+    Args:
+        dependency: The package whose dependents should be discovered.
+
+    Returns:
+        Tuple of imported module objects for all packages that depend on
+        `dependency`. Does not include `dependency` itself.
+    """
+    return tuple(
+        import_modules(
+            DependencyGraph.cached(root=dependency.__name__).sorted_ancestors(
+                dependency.__name__
+            )
+        )
+    )

pyrig_runtime-0.1.0/src/pyrig_runtime/core/dependencies/graph.py

@@ -0,0 +1,69 @@
+"""Directed graph of installed Python package dependency relationships."""
+
+import importlib.metadata
+import logging
+from collections.abc import Iterator
+
+from pyrig_runtime.core.graph import DiGraph
+from pyrig_runtime.core.strings import (
+    dependency_requirement_as_package_name,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class DependencyGraph(DiGraph):
+    """Directed graph of installed Python package dependencies.
+
+    Nodes are package names; an edge A → B means "A depends on B".
+    The graph is built at instantiation by scanning all installed
+    distributions.
+
+    When a `root` package is given, the graph is pruned to retain only
+    that package and every package that depends on it directly or
+    transitively.
+    """
+
+    def __init__(self, root: str | None = None) -> None:
+        """Initialize the dependency graph rooted at the given package.
+
+        Only `root` and packages that depend on it transitively are retained.
+
+        Args:
+            root: Name of the root package. Accepts either the installed name
+                (`some-package`) or the import name (`some_package`).
+        """
+        super().__init__(
+            root=dependency_requirement_as_package_name(root) if root else None
+        )
+
+    def build(self) -> None:
+        """Build the graph from installed Python distributions."""
+        logger.debug("Building dependency graph from installed distributions")
+        for dist in importlib.metadata.distributions():
+            name, deps = self.parse_name_and_deps(dist)
+            self.add_node(name)
+            for dep in deps:
+                self.add_edge(name, dep)  # package → dependency
+        logger.debug("Dependency graph built with %d packages", len(self.nodes()))
+
+    def parse_name_and_deps(
+        self, dist: importlib.metadata.Distribution
+    ) -> tuple[str, Iterator[str]]:
+        """Extract the package name and dependencies from a distribution.
+
+        Both the package name and every dependency name are normalized to
+        snake_case. The dependency iterator is exhausted once consumed; it
+        yields nothing when the distribution declares no dependencies.
+
+        Args:
+            dist: Distribution to extract metadata from.
+
+        Returns:
+            A two-tuple `(name, deps)` where `name` is the normalized package
+            name and `deps` is an iterator over the normalized name of each
+            declared dependency.
+        """
+        return dependency_requirement_as_package_name(dist.name), (
+            dependency_requirement_as_package_name(req) for req in (dist.requires or [])
+        )

pyrig_runtime-0.1.0/src/pyrig_runtime/core/dependencies/subclass.py

@@ -0,0 +1,180 @@
+"""Abstract base for cross-package subclass discovery without explicit registration."""
+
+import json
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Iterator
+from functools import cache
+from types import ModuleType
+from typing import Any, Self, TypeVar
+
+from pyrig import rig
+
+from pyrig_runtime.core.dependencies.discovery import (
+    discover_subclasses_across_dependencies,
+)
+from pyrig_runtime.core.introspection.classes import (
+    classproperty,
+    discard_abstract_classes,
+    discard_parent_classes,
+)
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T", bound="DependencySubclass")
+
+
+class DependencySubclass(ABC):
+    """Base class that enables the plugin-style extensibility across installed packages.
+
+    Subclasses declare a sub-package scope via `dependency_package()`, and
+    the discovery machinery automatically finds all concrete implementations
+    defined in that sub-package across every installed package that depends
+    on the root package. No explicit registration is required.
+
+    The `sort_key()` hook controls ordering when `subclasses_sorted()` is
+    used. The `L` classproperty provides a cached shortcut to the leaf
+    subclass type, and `I` provides a cached instance of it.
+    """
+
+    def __str__(self) -> str:
+        """Return the fully qualified class name of this instance."""
+        return f"{self.__module__}.{self.__class__.__name__}"
+
+    @classmethod
+    @abstractmethod
+    def dependency_package(cls) -> ModuleType:
+        """Return the sub-package that scopes subclass discovery for this hierarchy.
+
+        Every concrete subclass must override this to return the sub-package
+        where its own implementations are defined. The returned module's root
+        package determines which installed packages are searched.
+
+        The base implementation returns `pyrig.rig`, making it callable via
+        `super()` as a fallback or when calling `subclasses()` directly on
+        `DependencySubclass` itself.
+
+        Returns:
+            Package module whose path pattern is replicated across dependent
+            packages to locate the modules to search.
+        """
+        return rig
+
+    @classmethod
+    def sort_key(cls) -> Any:
+        """Return a stable sort key used by `subclasses_sorted()` to order subclasses.
+
+        Override to sort by priority, numeric position, or any other criterion.
+        The default returns the class name, giving alphabetical ordering.
+
+        Returns:
+            A value comparable by `sorted()`.
+        """
+        return cls.__name__
+
+    @classproperty
+    @cache  # noqa: B019  # false warning bc of custom classproperty decorator
+    def I(cls) -> Self:  # noqa: E743, N802, N805
+        """Return a cached instance of the leaf subclass.
+
+        The instance is created once per class and reused on every subsequent
+        access. Equivalent to instantiating the result of `cls.L`.
+
+        Returns:
+            An instance of the leaf subclass.
+
+        Raises:
+            RuntimeError: If more than one leaf subclass is found.
+        """
+        return cls.L()
+
+    @classproperty
+    @cache  # noqa: B019  # false warning bc of custom classproperty decorator
+    def L(cls) -> type[Self]:  # noqa: N802, N805
+        """Return the cached leaf subclass type.
+
+        Equivalent to `leaf()`, but the result is cached so repeated accesses
+        do not re-run discovery.
+
+        Returns:
+            The single leaf subclass type. May be abstract.
+
+        Raises:
+            RuntimeError: If more than one leaf subclass is found.
+        """
+        return cls.leaf()
+
+    @classmethod
+    def leaf(cls) -> type[Self]:
+        """Return the single leaf subclass found across dependent packages.
+
+        Calls `subclasses()` and expects at most one result. If no subclasses
+        are found, the class itself is returned. Raises `RuntimeError` if
+        multiple subclasses are found, because a leaf must be unambiguous:
+        exactly one active implementation is allowed.
+
+        Returns:
+            The sole leaf subclass type. May be abstract.
+
+        Raises:
+            RuntimeError: If more than one subclass is discovered across
+                the dependent packages.
+        """
+        subclasses = cls.subclasses()
+        leaf = next(subclasses, cls)
+        second = next(subclasses, None)
+        if second is None:
+            return leaf
+
+        msg = f"""Multiple leaf subclasses found for {cls}.
+Defining multiple leaf subclasses is ambiguous.
+This can happen if more than one leaf subclass is defined
+across all the dependent packages.
+
+Found subclasses:
+{json.dumps([str(subcls) for subcls in (leaf, second, *subclasses)], indent=4)}"""
+        raise RuntimeError(msg)
+
+    @classmethod
+    def concrete_subclasses(cls) -> Iterator[type[Self]]:
+        """Yield all non-abstract subclasses discovered across dependent packages.
+
+        Equivalent to `subclasses()` with abstract classes removed.
+
+        Yields:
+            Non-abstract subclass types.
+        """
+        return discard_abstract_classes(cls.subclasses())
+
+    @classmethod
+    def subclasses(cls) -> Iterator[type[Self]]:
+        """Yield all subclasses discovered across the package ecosystem.
+
+        Searches every installed package that depends on the root package of
+        `dependency_package()`. Intermediate parent classes are discarded,
+        leaving only the outermost leaf-level subclasses.
+
+        Yields:
+            Subclass types with intermediate parent classes removed.
+        """
+        return discard_parent_classes(
+            discover_subclasses_across_dependencies(
+                cls,
+                package=cls.dependency_package(),
+            )
+        )
+
+    @classmethod
+    def subclasses_sorted(cls, subclasses: Iterable[type[Self]]) -> list[type[Self]]:
+        """Sort the given subclasses using each subclass's `sort_key()`.
+
+        Does not perform any discovery. Pass any iterable of subclass types
+        to produce a deterministically ordered list.
+
+        Args:
+            subclasses: Subclass types to sort.
+
+        Returns:
+            The same subclass types sorted by their `sort_key()`.
+        """
+        return sorted(subclasses, key=lambda subclass: subclass.sort_key())