meh

Author: bartfeenstra

betty/collections.py

@@ -80,11 +80,15 @@ def __delitem__(self, key: _ResolvableKeyT) -> None:
 class _DictKeyedCollection(KeyedCollection[_KeyT, _ResolvableKeyT, _ValueT]):
     def __init__(
         self,
-        values: Mapping[_KeyT, _ValueT] | None = None,
+        values: Mapping[_KeyT | _ResolvableKeyT, _ValueT] | None = None,
         *,
         key_resolver: Callable[[_ResolvableKeyT | _KeyT], _KeyT] = passthrough,
     ):
-        self._values = {} if values is None else dict(values)
+        self._values = (
+            {}
+            if values is None
+            else {key_resolver(key): value for key, value in values.items()}
+        )
         self._key_resolver = key_resolver
 
     @override

betty/extension/raspberry_mint/content_provider.py

@@ -50,7 +50,7 @@
 )
 from betty.plugin.config.property import PluginConfigurationSequenceProperty
 from betty.plugin.data import PluginConfigurationSequenceDefinition, PluginIdDefinition
-from betty.plugin.resolve import resolve_id
+from betty.plugin.resolve import ResolvableDefinition, resolve_id
 from betty.portable import CallbackPorter
 from betty.service.level.factory import (
     ServiceLevelDependentSelfFactory,
@@ -66,7 +66,7 @@
     from betty.document import Document
     from betty.jinja2 import Environment
     from betty.locale.localizable import ResolvableLocalizable
-    from betty.plugin.repository import PluginRepository
+    from betty.plugin.collections import PluginDefinitions
     from betty.plugin.resolve import ResolvableId
 
 
@@ -189,7 +189,7 @@ def __init__(
         *,
         ancestry: Ancestry,
         configuration: EntityReference,
-        entity_types: PluginRepository[EntityDefinition],
+        entity_types: PluginDefinitions[EntityDefinition],
         jinja2_environment: Environment,
     ):
         super().__init__(
@@ -482,7 +482,7 @@ def __init__(
         self,
         *,
         jinja2_environment: Environment,
-        presence_roles: PluginRepository[PresenceRoleDefinition],
+        presence_roles: Iterable[ResolvableDefinition[PresenceRoleDefinition]],
         configuration: PresencesConfiguration | None = None,
     ):
         super().__init__(

betty/extension/spdx/__init__.py

@@ -10,14 +10,13 @@
 from betty.license import LicenseDefinition
 from betty.license.licenses import SpdxLicenseBuilder
 from betty.locale.localizable.gettext import _
-from betty.plugin.repository.static import StaticPluginRepository
+from betty.plugin.collections import PluginDefinitions, new_plugin_definitions
 from betty.service.container import service
 from betty.service.level.factory import ServiceLevelDependentSelfFactory
 from betty.service.requirement.extension import require_extension
 from betty.service.requirement.project import require_project
 
 if TYPE_CHECKING:
-    from betty.plugin.repository import PluginRepository
     from betty.project import Project
 
 
@@ -41,13 +40,12 @@ async def new_for_services(cls, *, project: Project) -> Self:
         return cls(project=project)
 
     @service
-    async def license_repository(self) -> PluginRepository[LicenseDefinition]:
+    async def licenses(self) -> PluginDefinitions[LicenseDefinition]:
         """
         The SPDX licenses.
         """
-        return StaticPluginRepository(
-            LicenseDefinition,
-            *[
+        return new_plugin_definitions(
+            *(
                 license
                 async for license in SpdxLicenseBuilder(  # noqa: A001
                     binary_file_cache=self._project.app.binary_file_cache.with_scope(
@@ -56,10 +54,10 @@ async def license_repository(self) -> PluginRepository[LicenseDefinition]:
                     http_client=await self._project.app.http_client,
                     user=self._project.app.user,
                 ).build()
-            ],
+            ),
         )
 
 
 LicenseDefinition.type().discoverer.add(
-    require_extension(Spdx)(lambda *, extension: extension.license_repository),
+    require_extension(Spdx)(lambda *, extension: extension.licenses),
 )

betty/plugin/assertion.py

@@ -9,14 +9,14 @@
 from betty.locale.localizable.gettext import _
 from betty.locale.localizable.markup import Paragraph, do_you_mean
 from betty.plugin import PluginDefinition
+from betty.plugin.collections import PluginDefinitions
 from betty.plugin.error import PluginNotFound
-from betty.plugin.repository import PluginRepository
 
 _PluginDefinitionT = TypeVar("_PluginDefinitionT", bound=PluginDefinition)
 
 
 def assert_plugin(
-    plugins: PluginRepository[_PluginDefinitionT],
+    plugins: PluginDefinitions[_PluginDefinitionT],
 ) -> AssertionChain[Any, _PluginDefinitionT]:
     """
     Assert that a value is a plugin ID.

betty/plugin/collections.py

@@ -0,0 +1,45 @@
+"""
+Plugin collections.
+"""
+
+from typing import TypeAlias
+
+from typing_extensions import TypeVar
+
+from betty.collections import DictKeyedCollection, KeyedCollection
+from betty.machine_name import MachineName
+from betty.plugin import PluginDefinition, PluginTypeDefinition
+from betty.plugin.resolve import ResolvableDefinition, ResolvableId, resolve_id
+
+_PluginDefinitionT = TypeVar(
+    "_PluginDefinitionT", bound=PluginDefinition, default=PluginDefinition
+)
+
+PluginDefinitions: TypeAlias = KeyedCollection[
+    MachineName, ResolvableId[_PluginDefinitionT], _PluginDefinitionT
+]
+PluginTypeDefinitions: TypeAlias = KeyedCollection[
+    MachineName, MachineName, PluginTypeDefinition
+]
+
+
+def new_plugin_definitions(
+    *plugins: ResolvableDefinition[_PluginDefinitionT],
+) -> PluginDefinitions[_PluginDefinitionT]:
+    """
+    Create a new collection of plugin definitions.
+    """
+    return DictKeyedCollection(
+        {resolve_id(plugin.id): plugin for plugin in plugins}, key_resolver=resolve_id
+    )
+
+
+def new_plugin_type_definitions(
+    *plugin_types: PluginTypeDefinition,
+) -> PluginTypeDefinitions:
+    """
+    Create a new collection of plugin type definitions.
+    """
+    return DictKeyedCollection(
+        {plugin_type.id: plugin_type for plugin_type in plugin_types}
+    )

betty/plugin/dependent.py

@@ -15,8 +15,8 @@
     from collections.abc import Iterable, Set
     from graphlib import TopologicalSorter
 
+    from betty.collections import KeyedCollection
     from betty.machine_name import MachineName
-    from betty.plugin.repository import PluginRepository
 
 
 _BaseClsCoT = TypeVar("_BaseClsCoT", default=object, covariant=True)
@@ -62,7 +62,7 @@ def depends_on(self) -> Set[MachineName]:
 
 
 async def expand_plugin_dependencies(
-    plugin_repository: PluginRepository[_DependentPluginDefinitionT],
+    available_plugins: KeyedCollection[Any, ResolvableId, _DependentPluginDefinitionT],
     plugins: Iterable[_DependentPluginDefinitionT],
     /,
 ) -> Set[_DependentPluginDefinitionT]:
@@ -74,21 +74,21 @@ async def expand_plugin_dependencies(
         dependencies.add(plugin)
         dependencies.update(
             await expand_plugin_dependencies(
-                plugin_repository,
-                [plugin_repository.get(depends_on) for depends_on in plugin.depends_on],
+                available_plugins,
+                [available_plugins[depends_on] for depends_on in plugin.depends_on],
             )
         )
     return dependencies
 
 
 async def sort_dependent_plugin_graph(
-    plugin_repository: PluginRepository[_DependentPluginDefinitionT],
+    available_plugins: KeyedCollection[Any, ResolvableId, _DependentPluginDefinitionT],
     plugins: Iterable[_DependentPluginDefinitionT],
     /,
 ) -> TopologicalSorter[MachineName]:
     """
     Sort a dependent plugin graph.
     """
     return sort_ordered_plugin_graph(
-        plugin_repository, await expand_plugin_dependencies(plugin_repository, plugins)
+        available_plugins, await expand_plugin_dependencies(available_plugins, plugins)
     )

betty/plugin/manager/__init__.py

@@ -9,7 +9,7 @@
 
 from typing_extensions import TypeVar
 
-from betty.plugin import PluginDefinition, PluginTypeRepository
+from betty.plugin import PluginDefinition, PluginTypeDefinition
 from betty.typing import threadsafe
 
 if TYPE_CHECKING:
@@ -40,7 +40,7 @@ async def plugins(
 
     @property
     @abstractmethod
-    def types(self) -> PluginTypeRepository:
+    def types(self) -> KeyedCollection[MachineName, MachineName, PluginTypeDefinition]:
         """
         Get the available plugin types.
         """

betty/plugin/manager/service.py

@@ -5,23 +5,25 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, cast, final
+from importlib import metadata
+from typing import TYPE_CHECKING, cast, final
 
 from typing_extensions import TypeVar, override
 
-from betty import plugin
 from betty.concurrent import AsynchronizedLock, Ledger
-from betty.plugin import PluginDefinition
+from betty.plugin import PluginDefinition, PluginTypeDefinition
+from betty.plugin.collections import (
+    PluginDefinitions,
+    new_plugin_definitions,
+    new_plugin_type_definitions,
+)
 from betty.plugin.manager import PluginManager
-from betty.plugin.repository.static import StaticPluginRepository
 
 if TYPE_CHECKING:
     from collections.abc import MutableMapping
 
     from betty.collections import KeyedCollection
     from betty.machine_name import MachineName
-    from betty.plugin.repository import PluginRepository
-    from betty.plugin.resolve import ResolvableId
     from betty.service.level import ServiceLevel
 
 
@@ -39,52 +41,54 @@ class ServiceLevelPluginManager(PluginManager):
 
     def __init__(self, services: ServiceLevel, /):
         self._services = services
-        self._types = plugin.PluginTypeRepository()
-        self._plugin_repositories: MutableMapping[
-            type[PluginDefinition], PluginRepository[Any] | None
+        self._types = new_plugin_type_definitions(
+            *(
+                entry_point.load()
+                for entry_point in metadata.entry_points(group="betty.plugin")
+            )
+        )
+        self._plugins: MutableMapping[
+            type[PluginDefinition], PluginDefinitions | None
         ] = defaultdict(None)
         self._ledger = Ledger(AsynchronizedLock.new_threadsafe())
 
     @override
     @property
-    def types(self) -> plugin.PluginTypeRepository:
+    def types(self) -> KeyedCollection[MachineName, MachineName, PluginTypeDefinition]:
         return self._types
 
     @override
     async def plugins(
         self, plugin_type: type[_PluginDefinitionT] | MachineName, /
-    ) -> KeyedCollection[
-        MachineName, ResolvableId[_PluginDefinitionT], _PluginDefinitionT
-    ]:
+    ) -> PluginDefinitions[_PluginDefinitionT]:
         if isinstance(plugin_type, str):
             plugin_type = cast(type[_PluginDefinitionT], self.types[plugin_type])
-        repository: PluginRepository[_PluginDefinitionT] | None
+        plugins: PluginDefinitions[_PluginDefinitionT] | None
         if plugin_type.type().discoverer.overridden:
             return await self._new(plugin_type)
-        # If the repository exists already, return it immediately so we avoid acquiring locks.
-        repository = self._get(plugin_type)
-        if repository:
-            return repository
+        # If the definitions exist already, return them immediately so we avoid acquiring locks.
+        plugins = self._get(plugin_type)
+        if plugins:
+            return plugins
         async with self._ledger.ledger(f"{plugin_type.type().id}"):
-            # The repository may have been created since we first checked.
-            repository = self._get(plugin_type)
-            if repository:
-                return repository
-            repository = await self._new(plugin_type)
-            self._plugin_repositories[plugin_type] = repository
-            return repository
+            # The definitions may have been created since we first checked.
+            plugins = self._get(plugin_type)
+            if plugins:
+                return plugins
+            plugins = await self._new(plugin_type)
+            self._plugins[plugin_type] = plugins
+            return plugins
 
     def _get(
         self, plugin_type: type[_PluginDefinitionT]
-    ) -> PluginRepository[_PluginDefinitionT] | None:
-        if plugin_type not in self._plugin_repositories:
+    ) -> PluginDefinitions[_PluginDefinitionT] | None:
+        if plugin_type not in self._plugins:
             return None
-        return self._plugin_repositories[plugin_type]
+        return self._plugins[plugin_type]
 
     async def _new(
         self, plugin_type: type[_PluginDefinitionT]
-    ) -> PluginRepository[_PluginDefinitionT]:
-        return StaticPluginRepository(
-            plugin_type,
-            *await plugin_type.type().discoverer.discover(services=self._services),
+    ) -> PluginDefinitions[_PluginDefinitionT]:
+        return new_plugin_definitions(
+            *await plugin_type.type().discoverer.discover(services=self._services)
         )