✨ builtin plugin auto_reload

Author: RF-Tar-Railt

arclet/entari/core.py

@@ -16,7 +16,7 @@
 
 from .command import _commands
 from .event import MessageCreatedEvent, event_parse
-from .plugin.service import service
+from .plugin.service import plugin_service
 from .session import Session
 
 
@@ -78,15 +78,15 @@ def on_message(
 
     def ensure_manager(self, manager: Launart):
         self.manager = manager
-        manager.add_component(service)
+        manager.add_component(plugin_service)
 
     async def handle_event(self, account: Account, event: Event):
         async def event_parse_task(connection: Account, raw: Event):
             loop = asyncio.get_running_loop()
             with suppress(NotImplementedError):
                 ev = event_parse(connection, raw)
                 self.event_system.publish(ev)
-                for plugin in service.plugins.values():
+                for plugin in plugin_service.plugins.values():
                     for disp in plugin.dispatchers.values():
                         if not disp.validate(ev):
                             continue
@@ -104,7 +104,7 @@ async def event_parse_task(connection: Account, raw: Event):
     async def account_hook(self, account: Account, state: LoginStatus):
         _connected = []
         _disconnected = []
-        for plug in service.plugins.values():
+        for plug in plugin_service.plugins.values():
             _connected.extend([func(account) for func in plug._connected])
             _disconnected.extend([func(account) for func in plug._disconnected])
         if state == LoginStatus.CONNECT:

arclet/entari/plugin/__init__.py

@@ -13,7 +13,7 @@
 from .model import keeping as keeping
 from .module import import_plugin
 from .module import package as package
-from .service import service
+from .service import plugin_service
 
 if TYPE_CHECKING:
     from ..event import Event
@@ -25,42 +25,44 @@ def dispatch(*events: type[Event], predicate: Callable[[Event], bool] | None = N
     return plugin.dispatch(*events, predicate=predicate)
 
 
-def load_plugin(path: str, recursive_guard: set[str] | None = None) -> Plugin | None:
+def load_plugin(path: str, config: dict | None = None, recursive_guard: set[str] | None = None) -> Plugin | None:
     """
     以导入路径方式加载模块
 
     Args:
         path (str): 模块路径
+        config (dict): 模块配置
         recursive_guard (set[str]): 递归保护
     """
     if recursive_guard is None:
         recursive_guard = set()
-    if path in service._submoded:
-        logger.error(f"plugin {path!r} is already defined as submodule of {service._submoded[path]!r}")
+    path = path.replace("::", "arclet.entari.plugins.")
+    if path in plugin_service._submoded:
+        logger.error(f"plugin {path!r} is already defined as submodule of {plugin_service._submoded[path]!r}")
         return
-    if path in service.plugins:
-        return service.plugins[path]
+    if path in plugin_service.plugins:
+        return plugin_service.plugins[path]
     try:
-        mod = import_plugin(path)
+        mod = import_plugin(path, config=config)
         if not mod:
             logger.error(f"cannot found plugin {path!r}")
             return
         logger.success(f"loaded plugin {path!r}")
-        if mod.__name__ in service._unloaded:
-            if mod.__name__ in service._referents and service._referents[mod.__name__]:
-                referents = service._referents[mod.__name__].copy()
-                service._referents[mod.__name__].clear()
+        if mod.__name__ in plugin_service._unloaded:
+            if mod.__name__ in plugin_service._referents and plugin_service._referents[mod.__name__]:
+                referents = plugin_service._referents[mod.__name__].copy()
+                plugin_service._referents[mod.__name__].clear()
                 for referent in referents:
                     if referent in recursive_guard:
                         continue
-                    if referent in service.plugins:
+                    if referent in plugin_service.plugins:
                         logger.debug(f"reloading {mod.__name__}'s referent {referent!r}")
                         dispose(referent)
                         if not load_plugin(referent):
-                            service._referents[mod.__name__].add(referent)
+                            plugin_service._referents[mod.__name__].add(referent)
                         else:
                             recursive_guard.add(referent)
-            service._unloaded.discard(mod.__name__)
+            plugin_service._unloaded.discard(mod.__name__)
         return mod.__plugin__
     except RegisterNotInPluginError as e:
         logger.exception(f"{e.args[0]}", exc_info=e)
@@ -79,9 +81,9 @@ def load_plugins(dir_: str | PathLike | Path):
 
 
 def dispose(plugin: str):
-    if plugin not in service.plugins:
+    if plugin not in plugin_service.plugins:
         return False
-    _plugin = service.plugins[plugin]
+    _plugin = plugin_service.plugins[plugin]
     _plugin.dispose()
     return True
 
@@ -91,3 +93,31 @@ def metadata(data: PluginMetadata):
     if not (plugin := _current_plugin.get(None)):
         raise LookupError("no plugin context found")
     plugin._metadata = data  # type: ignore
+
+
+def find_plugin(name: str) -> Plugin | None:
+    if name in plugin_service.plugins:
+        return plugin_service.plugins[name]
+    if name in plugin_service._submoded:
+        return plugin_service.plugins[plugin_service._submoded[name]]
+    return None
+
+
+def find_plugin_by_file(file: str) -> Plugin | None:
+    path = Path(file).resolve()
+    for plugin in plugin_service.plugins.values():
+        if plugin.module.__file__ == str(path):
+            return plugin
+        if plugin.module.__file__ and Path(plugin.module.__file__).parent == path:
+            return plugin
+        for submod in plugin.submodules.values():
+            if submod.__file__ == str(path):
+                return plugin
+            if submod.__file__ and Path(submod.__file__).parent == path:
+                return plugin
+        path1 = Path(path)
+        while path1.parent != path1:
+            if str(path1) == plugin.module.__file__:
+                return plugin
+            path1 = path1.parent
+    return None

arclet/entari/plugin/model.py

@@ -13,9 +13,11 @@
 from arclet.letoderea import BaseAuxiliary, Provider, Publisher, StepOut, system_ctx
 from arclet.letoderea.builtin.breakpoint import R
 from arclet.letoderea.typing import TTarget
+from creart import it
+from launart import Launart, Service
 from satori.client import Account
 
-from .service import service
+from .service import plugin_service
 
 if TYPE_CHECKING:
     from ..event import Event
@@ -113,6 +115,7 @@ class Plugin:
     module: ModuleType
     dispatchers: dict[str, PluginDispatcher] = field(default_factory=dict)
     submodules: dict[str, ModuleType] = field(default_factory=dict)
+    config: dict[str, Any] = field(default_factory=dict)
     _metadata: PluginMetadata | None = None
     _is_disposed: bool = False
 
@@ -121,6 +124,8 @@ class Plugin:
     _connected: list[_AccountUpdate] = field(init=False, default_factory=list)
     _disconnected: list[_AccountUpdate] = field(init=False, default_factory=list)
 
+    _services: dict[str, Service] = field(init=False, default_factory=dict)
+
     def on_prepare(self, func: _Lifespan):
         self._preparing.append(func)
         return func
@@ -149,15 +154,15 @@ def metadata(self) -> PluginMetadata | None:
         return self._metadata
 
     def __post_init__(self):
-        service.plugins[self.id] = self
-        if self.id not in service._keep_values:
-            service._keep_values[self.id] = {}
-        if self.id not in service._referents:
-            service._referents[self.id] = set()
+        plugin_service.plugins[self.id] = self
+        if self.id not in plugin_service._keep_values:
+            plugin_service._keep_values[self.id] = {}
+        if self.id not in plugin_service._referents:
+            plugin_service._referents[self.id] = set()
         finalize(self, self.dispose)
 
     def dispose(self):
-        service._unloaded.add(self.id)
+        plugin_service._unloaded.add(self.id)
         if self._is_disposed:
             return
         self._is_disposed = True
@@ -168,15 +173,21 @@ def dispose(self):
         for submod in self.submodules.values():
             delattr(submod, "__plugin__")
             sys.modules.pop(submod.__name__, None)
-            service._submoded.pop(submod.__name__, None)
+            plugin_service._submoded.pop(submod.__name__, None)
             if submod.__spec__ and submod.__spec__.cached:
                 Path(submod.__spec__.cached).unlink(missing_ok=True)
         self.submodules.clear()
         for disp in self.dispatchers.values():
             disp.dispose()
         self.dispatchers.clear()
-        del service.plugins[self.id]
+        del plugin_service.plugins[self.id]
         del self.module
+        for serv in self._services.values():
+            try:
+                it(Launart).remove_component(serv)
+            except ValueError:
+                pass
+        self._services.clear()
 
     def dispatch(self, *events: type[Event], predicate: Callable[[Event], bool] | None = None):
         disp = PluginDispatcher(self, *events, predicate=predicate)
@@ -202,6 +213,14 @@ def proxy(self):
     def subproxy(self, sub_id: str):
         return _ProxyModule(self.id, sub_id)
 
+    def service(self, serv: Service | type[Service]):
+        if isinstance(serv, type):
+            serv = serv()
+        self._services[serv.id] = serv
+        if plugin_service.status.blocking:
+            it(Launart).add_component(serv)
+        return serv
+
 
 class KeepingVariable:
     def __init__(self, obj: T, dispose: Callable[[T], None] | None = None):
@@ -222,10 +241,10 @@ def dispose(self):
 def keeping(id_: str, obj: T, dispose: Callable[[T], None] | None = None) -> T:
     if not (plug := _current_plugin.get(None)):
         raise LookupError("no plugin context found")
-    if id_ not in service._keep_values[plug.id]:
-        service._keep_values[plug.id][id_] = KeepingVariable(obj, dispose)
+    if id_ not in plugin_service._keep_values[plug.id]:
+        plugin_service._keep_values[plug.id][id_] = KeepingVariable(obj, dispose)
     else:
-        obj = service._keep_values[plug.id][id_].obj  # type: ignore
+        obj = plugin_service._keep_values[plug.id][id_].obj  # type: ignore
     return obj
 
 
@@ -240,12 +259,12 @@ def __get_module(self) -> ModuleType:
     def __init__(self, plugin_id: str, sub_id: str | None = None) -> None:
         self.__plugin_id = plugin_id
         self.__sub_id = sub_id
-        if self.__plugin_id not in service.plugins:
+        if self.__plugin_id not in plugin_service.plugins:
             raise NameError(f"Plugin {self.__plugin_id!r} is not loaded")
         if self.__sub_id:
-            self.__origin = ref(service.plugins[self.__plugin_id].submodules[self.__sub_id])
+            self.__origin = ref(plugin_service.plugins[self.__plugin_id].submodules[self.__sub_id])
         else:
-            self.__origin = ref(service.plugins[self.__plugin_id].module)
+            self.__origin = ref(plugin_service.plugins[self.__plugin_id].module)
         super().__init__(self.__get_module().__name__)
         self.__doc__ = self.__get_module().__doc__
         self.__file__ = self.__get_module().__file__
@@ -278,14 +297,14 @@ def __getattr__(self, name: str):
             "__spec__",
         ):
             return super().__getattribute__(name)
-        if self.__plugin_id not in service.plugins:
+        if self.__plugin_id not in plugin_service.plugins:
             raise NameError(f"Plugin {self.__plugin_id!r} is not loaded")
         if plug := inspect.currentframe().f_back.f_globals.get("__plugin__"):  # type: ignore
             if plug.id != self.__plugin_id:
-                service._referents[self.__plugin_id].add(plug.id)
+                plugin_service._referents[self.__plugin_id].add(plug.id)
         elif plug := inspect.currentframe().f_back.f_back.f_globals.get("__plugin__"):  # type: ignore
             if plug.id != self.__plugin_id:
-                service._referents[self.__plugin_id].add(plug.id)
+                plugin_service._referents[self.__plugin_id].add(plug.id)
         return getattr(self.__get_module(), name)
 
     def __setattr__(self, name: str, value):