🍻 filter use propagator & depends

Author: RF-Tar-Railt

Diff for: arclet/entari/builtins/auto_reload.py

@@ -40,15 +40,7 @@ def detect_filter_change(old: dict, new: dict):
     added = set(new) - set(old)
     removed = set(old) - set(new)
     changed = {key for key in set(new) & set(old) if new[key] != old[key]}
-    if "$allow" in removed:
-        allow = {}
-    else:
-        allow = new.get("$allow", {})
-    if "$deny" in removed:
-        deny = {}
-    else:
-        deny = new.get("$deny", {})
-    return allow, deny, not ((added | removed | changed) - {"$allow", "$deny"})
+    return "allow" in (added | removed | changed) or "$deny" in (added | removed | changed)
 
 
 class Watcher(Service):
@@ -106,7 +98,6 @@ async def watch_config(self):
                     or Path(change[1]).resolve() in extra
                     or Path(change[1]).resolve().parent in extra
                 ):
-                    print(change)
                     continue
                 logger.info(f"Detected change in {change[1]!r}, reloading config...")
 
@@ -141,20 +132,17 @@ async def watch_config(self):
                         old_conf = old_plugin[plugin_name]
                         new_conf = EntariConfig.instance.plugin[plugin_name]
                         if plugin := find_plugin(pid):
-                            allow, deny, only_filter = detect_filter_change(old_conf, new_conf)
-                            plugin.update_filter(allow, deny)
-                            if only_filter:
-                                logger.debug(f"Plugin <y>{pid!r}</y> config only changed filter.")
-                                continue
-                            res = await es.post(
-                                ConfigReload("plugin", plugin_name, new_conf, old_conf),
-                            )
-                            if res and res.value:
-                                logger.debug(f"Plugin <y>{pid!r}</y> config change handled by itself.")
-                                continue
+                            filter_changed = detect_filter_change(old_conf, new_conf)
+                            if not filter_changed:
+                                res = await es.post(
+                                    ConfigReload("plugin", plugin_name, new_conf, old_conf),
+                                )
+                                if res and res.value:
+                                    logger.debug(f"Plugin <y>{pid!r}</y> config change handled by itself.")
+                                    continue
                             logger.info(f"Detected config of <blue>{pid!r}</blue> changed, reloading...")
                             plugin_file = str(plugin.module.__file__)
-                            unload_plugin(plugin_name)
+                            unload_plugin(pid)
                             if plugin := load_plugin(plugin_name, new_conf):
                                 logger.info(f"Reloaded <blue>{plugin.id!r}</blue>")
                                 del plugin

Diff for: arclet/entari/filter/__init__.py

@@ -7,6 +7,7 @@
 from ..message import MessageChain
 from ..session import Session
 from .common import filter_ as filter_
+from .common import parse as parse
 from .message import direct_message
 from .message import notice_me as notice_me
 from .message import public_message
@@ -57,7 +58,7 @@ async def before(self, session: Optional[Session] = None):
                 await session.send(self.limit_prompt)
             return STOP
 
-    async def after(self) -> Optional[bool]:
+    async def after(self):
         self.semaphore.release()
 
     def compose(self):

Diff for: arclet/entari/filter/common.py

@@ -1,32 +1,88 @@
 from collections.abc import Awaitable
+from inspect import Parameter, Signature
 from typing import Callable, Union
 from typing_extensions import TypeAlias
 
-from arclet.letoderea import STOP
-from arclet.letoderea.handler import run_handler
-from arclet.letoderea.typing import run_sync
+from arclet.letoderea import STOP, Contexts, Depends, Propagator, propagate
+from arclet.letoderea.typing import Result, run_sync
+from satori import Channel, ChannelType, Guild, User
 from tarina import is_coroutinefunction
 
-from ..event.base import MessageEvent
 from ..session import Session
-from .message import direct_message, notice_me, public_message, reply_me, to_me
 
 _SessionFilter: TypeAlias = Union[Callable[[Session], bool], Callable[[Session], Awaitable[bool]]]
-_sess_keys = {
-    "user",
-    "guild",
-    "channel",
-    "self",
-    "platform",
+
+
+async def _direct_message(channel: Channel):
+    return Result(channel.type == ChannelType.DIRECT)
+
+
+async def _public_message(channel: Channel):
+    return Result(channel.type != ChannelType.DIRECT)
+
+
+async def _reply_me(is_reply_me: bool = False):
+    return Result(is_reply_me)
+
+
+async def _notice_me(is_notice_me: bool = False):
+    return Result(is_notice_me)
+
+
+async def _to_me(is_reply_me: bool = False, is_notice_me: bool = False):
+    return Result(is_reply_me or is_notice_me)
+
+
+def _user(*ids: str):
+    async def check_user(user: User):
+        return Result(user.id in ids if ids else True)
+
+    return check_user
+
+
+def _channel(*ids: str):
+    async def check_channel(channel: Channel):
+        return Result(channel.id in ids if ids else True)
+
+    return check_channel
+
+
+def _guild(*ids: str):
+    async def check_guild(guild: Guild):
+        return Result(guild.id in ids if ids else True)
+
+    return check_guild
+
+
+def _account(*ids: str):
+    async def check_account(session: Session):
+        return Result(session.account.self_id in ids)
+
+    return check_account
+
+
+def _platform(*ids: str):
+    async def check_platform(session: Session):
+        return Result(session.account.platform in ids)
+
+    return check_platform
+
+
+_keys = {
+    "user": (_user, 2),
+    "guild": (_guild, 3),
+    "channel": (_channel, 4),
+    "self": (_account, 1),
+    "platform": (_platform, 0),
 }
 
-_message_keys = {
-    "direct": direct_message,
-    "private": direct_message,
-    "public": public_message,
-    "reply_me": reply_me,
-    "notice_me": notice_me,
-    "to_me": to_me,
+_mess_keys = {
+    "direct": (_direct_message, 5),
+    "private": (_direct_message, 5),
+    "public": (_public_message, 6),
+    "reply_me": (_reply_me, 7),
+    "notice_me": (_notice_me, 8),
+    "to_me": (_to_me, 9),
 }
 
 _op_keys = {
@@ -54,46 +110,75 @@ async def _(session: Session):
     return _
 
 
+class _Filter(Propagator):
+    def __init__(self):
+        self.step: dict[int, Callable] = {}
+        self.ops = []
+
+    def get_flow(self):
+        if not self.step:
+            return Depends(lambda: None)
+
+        steps = [slot[1] for slot in sorted(self.step.items(), key=lambda x: x[0])]
+
+        @propagate(*steps, prepend=True)
+        async def flow(ctx: Contexts):
+            if ctx.get("$result", False):
+                return
+            return STOP
+
+        return Depends(flow)
+
+    def generate(self):
+
+        if not self.ops:
+
+            async def check(res=self.get_flow()):  # type: ignore
+                return res
+
+        else:
+
+            async def check(**kwargs):
+                res = kwargs["res"]
+                for (op, _), res1 in zip(self.ops, list(kwargs.values())[1:]):
+                    if op == "and" and (res is None and res1 is None):
+                        continue
+                    if op == "or" and (res is None or res1 is None):
+                        res = None
+                        continue
+                    if op == "not" and (res is None and res1 is STOP):
+                        continue
+                    res = STOP
+                return res
+
+            param = [Parameter("res", Parameter.POSITIONAL_OR_KEYWORD, default=self.get_flow())]
+            for index, slot in enumerate(self.ops):
+                param.append(
+                    Parameter(f"res_{index+1}", Parameter.POSITIONAL_OR_KEYWORD, default=Depends(slot[1].generate()))
+                )
+            check.__signature__ = Signature(param)
+
+        return check
+
+    def compose(self):
+        yield self.generate(), True, 0
+
+
 def parse(patterns: PATTERNS):
-    step: list[Callable[[Session], bool]] = []
-    other = []
-    ops = []
+    f = _Filter()
+
     for key, value in patterns.items():
-        if key in _sess_keys:
-            step.append(lambda session: getattr(session, key) in value)
-        elif key in _message_keys:
-            step.append(lambda session: isinstance(session.event, MessageEvent))
-            other.append(_message_keys[key])
+        if key in _keys:
+            f.step[_keys[key][1]] = _keys[key][0](*value)
+        elif key in _mess_keys:
+            if value is True:
+                f.step[_mess_keys[key][1]] = _mess_keys[key][0]
         elif key in _op_keys:
             op = _op_keys[key]
             if not isinstance(value, dict):
                 raise ValueError(f"Expect a dict for operator {key}")
-            ops.append((op, parse(value)))
+            f.ops.append((op, parse(value)))
         else:
             raise ValueError(f"Unknown key: {key}")
 
-    async def f(session: Session):
-        for i in step:
-            if not i(session):
-                return STOP
-        for i in other:
-            if not await run_handler(i, session.event):
-                return STOP
-
-    if not ops:
-        return f
-
-    async def _(session: Session):
-        res = await f(session)
-
-        for op, f_ in ops:
-            res1 = await f_(session)
-            if op == "and" and (res is None and res1 is None):
-                return
-            if op == "or" and (res is None or res1 is None):
-                return
-            if op == "not" and (res is None and res1 is STOP):
-                return
-            return STOP
-
-    return _
+    return f

Diff for: arclet/entari/logger.py

@@ -38,7 +38,9 @@ def message(self):
 
     def wrapper(self, name: str, color: str = "blue"):
         patched = logger.patch(
-            lambda r: r.update(name="entari", extra=r["extra"] | {"entari_plugin_name": name, "entari_plugin_color": color})
+            lambda r: r.update(
+                name="entari", extra=r["extra"] | {"entari_plugin_name": name, "entari_plugin_color": color}
+            )
         )
         patched = patched.bind(name=f"plugins.{name}")
         self.loggers[f"plugin.{name}"] = patched

Diff for: arclet/entari/plugin/model.py

@@ -15,7 +15,7 @@
 from launart import Launart, Service
 from tarina import ContextModel
 
-from ..filter.common import parse
+from ..filter import parse
 from ..logger import log
 from .service import plugin_service
 
@@ -216,20 +216,18 @@ def collect(self, *disposes: Callable[[], None]):
         self._dispose_callbacks.extend(disposes)
         return self
 
-    def update_filter(self, allow: dict, deny: dict):
-        if not allow and not deny:
-            return
+    def __post_init__(self):
+        self._scope = es.scope(self.id)
+        plugin_service.plugins[self.id] = self
+        allow = self.config.pop("$allow", {})
+        deny = self.config.pop("$deny", {})
         pat = {}
         if allow:
             pat["$and"] = allow
         if deny:
             pat["$not"] = deny
-        plugin_service.filters[self.id] = parse(pat)
-
-    def __post_init__(self):
-        self._scope = es.scope(self.id)
-        plugin_service.plugins[self.id] = self
-        self.update_filter(self.config.pop("$allow", {}), self.config.pop("$deny", {}))
+        if pat:
+            self._scope.propagators.append(parse(pat))
         if "$static" in self.config:
             self.is_static = True
             self.config.pop("$static")
@@ -271,6 +269,7 @@ def dispose(self):
                     plugin_service.plugins.pop(subplug, None)
             self.subplugins.clear()
         self._scope.dispose()
+        self._scope.propagators.clear()
         del plugin_service.plugins[self.id]
         del self.module
 

Diff for: arclet/entari/plugin/module.py

@@ -13,7 +13,7 @@
 from ..config import EntariConfig
 from ..logger import log
 from .model import Plugin, PluginMetadata, _current_plugin
-from .service import PluginAccess, plugin_service
+from .service import plugin_service
 
 _SUBMODULE_WAITLIST: dict[str, set[str]] = {}
 _ENSURE_IS_PLUGIN: set[str] = set()
@@ -217,11 +217,9 @@ def create_module(self, spec) -> Optional[ModuleType]:
         return super().create_module(spec)
 
     def exec_module(self, module: ModuleType, config: Optional[dict[str, str]] = None) -> None:
-        is_sub = False
         if plugin := plugin_service.plugins.get(self.parent_plugin_id) if self.parent_plugin_id else None:
             plugin.subplugins.add(module.__name__)
             plugin_service._subplugined[module.__name__] = plugin.id
-            is_sub = True
 
         if self.loaded:
             return
@@ -238,8 +236,6 @@ def exec_module(self, module: ModuleType, config: Optional[dict[str, str]] = Non
         # enter plugin context
         token = _current_plugin.set(plugin)
         if not plugin.is_static:
-            if not is_sub:
-                plugin._scope.propagators.append(PluginAccess(plugin.id))
             token1 = scope_ctx.set(plugin._scope)
         try:
             super().exec_module(module)