pico-ioc 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

pico_ioc/container.py

@@ -1,168 +1,305 @@
-from __future__ import annotations
-
+# src/pico_ioc/container.py
 import inspect
-from typing import Any, Dict, get_origin, get_args, Annotated
-import typing as _t
+import contextvars
+from typing import Any, Dict, List, Optional, Tuple, overload, Union
+from contextlib import contextmanager
+from .constants import LOGGER, PICO_META
+from .exceptions import CircularDependencyError, ComponentCreationError, ProviderNotFoundError
+from .factory import ComponentFactory
+from .locator import ComponentLocator
+from .scope import ScopedCaches, ScopeManager
+from .aop import UnifiedComponentProxy, ContainerObserver
 
-from .proxy import IoCProxy
-from .interceptors import MethodInterceptor, ContainerInterceptor, MethodCtx, ResolveCtx, CreateCtx, run_resolve_chain, run_create_chain
-from .decorators import QUALIFIERS_KEY
-from . import _state
+KeyT = Union[str, type]
+_resolve_chain: contextvars.ContextVar[Tuple[KeyT, ...]] = contextvars.ContextVar("pico_resolve_chain", default=())
 
-class Binder:
-    def __init__(self, container: PicoContainer):
-        self._c = container
+class PicoContainer:
+    _container_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("pico_container_id", default=None)
+    _container_registry: Dict[str, "PicoContainer"] = {}
 
-    def bind(self, key: Any, provider, *, lazy: bool, tags: tuple[str, ...] = ()):
-        self._c.bind(key, provider, lazy=lazy, tags=tags)
+    class _Ctx:
+        def __init__(self, container_id: str, profiles: Tuple[str, ...], created_at: float) -> None:
+            self.container_id = container_id
+            self.profiles = profiles
+            self.created_at = created_at
+            self.resolve_count = 0
+            self.cache_hit_count = 0
 
-    def has(self, key: Any) -> bool:
-        return self._c.has(key)
+    def __init__(self, component_factory: ComponentFactory, caches: ScopedCaches, scopes: ScopeManager, observers: Optional[List["ContainerObserver"]] = None, container_id: Optional[str] = None, profiles: Tuple[str, ...] = ()) -> None:
+        self._factory = component_factory
+        self._caches = caches
+        self.scopes = scopes
+        self._locator: Optional[ComponentLocator] = None
+        self._observers = list(observers or [])
+        self.container_id = container_id or self._generate_container_id()
+        import time as _t
+        self.context = PicoContainer._Ctx(container_id=self.container_id, profiles=profiles, created_at=_t.time())
+        PicoContainer._container_registry[self.container_id] = self
 
-    def get(self, key: Any):
-        return self._c.get(key)
+    @staticmethod
+    def _generate_container_id() -> str:
+        import time as _t, random as _r
+        return f"c{_t.time_ns():x}{_r.randrange(1<<16):04x}"
 
-class PicoContainer:
-    def __init__(self, providers: Dict[Any, Dict[str, Any]] | None = None):
-        self._providers = providers or {}
-        self._singletons: Dict[Any, Any] = {}
-        self._method_interceptors: tuple[MethodInterceptor, ...] = ()
-        self._container_interceptors: tuple[ContainerInterceptor, ...] = ()
-        self._active_profiles: tuple[str, ...] = ()
-        self._seen_interceptor_types: set[type] = set()
-        self._method_cap: int | None = None
-
-    def add_method_interceptor(self, it: MethodInterceptor) -> None:
-        self._method_interceptors = self._method_interceptors + (it,)
-
-    def add_container_interceptor(self, it: ContainerInterceptor) -> None:
-        t = type(it)
-        if t in self._seen_interceptor_types:
-            return
-        self._seen_interceptor_types.add(t)
-        self._container_interceptors = self._container_interceptors + (it,)
-
-    def set_method_cap(self, n: int | None) -> None:
-        self._method_cap = (int(n) if n is not None else None)
-
-    def binder(self) -> Binder:
-        return Binder(self)
-
-    def bind(self, key: Any, provider, *, lazy: bool, tags: tuple[str, ...] = ()):
-        self._singletons.pop(key, None)
-        meta = {"factory": provider, "lazy": bool(lazy)}
-        try:
-            q = getattr(key, QUALIFIERS_KEY, ())
-        except Exception:
-            q = ()
-        meta["qualifiers"] = tuple(q) if q else ()
-        meta["tags"] = tuple(tags) if tags else ()
-        self._providers[key] = meta
-
-    def has(self, key: Any) -> bool:
-        return key in self._providers
-
-    def _notify_resolve(self, key: Any, ann: Any, quals: tuple[str, ...] | tuple()):
-        ctx = ResolveCtx(key=key, qualifiers={q: True for q in quals or ()}, requested_by=None, profiles=self._active_profiles)
-        run_resolve_chain(self._container_interceptors, ctx)
-
-    def get(self, key: Any):
-        if _state._scanning.get() and not _state._resolving.get():
-            raise RuntimeError("re-entrant container access during scan")
-        prov = self._providers.get(key)
-        if prov is None:
-            raise NameError(f"No provider found for key {key!r}")
-        if key in self._singletons:
-            return self._singletons[key]
-        def base_provider():
-            return prov["factory"]()
-        cls = key if isinstance(key, type) else None
-        ctx = CreateCtx(key=key, component=cls, provider=base_provider, profiles=self._active_profiles)
-        tok = _state._resolving.set(True)
+    @classmethod
+    def get_current(cls) -> Optional["PicoContainer"]:
+        cid = cls._container_id_var.get()
+        return cls._container_registry.get(cid) if cid else None
+
+    @classmethod
+    def get_current_id(cls) -> Optional[str]:
+        return cls._container_id_var.get()
+
+    @classmethod
+    def all_containers(cls) -> Dict[str, "PicoContainer"]:
+        return dict(cls._container_registry)
+
+    def activate(self) -> contextvars.Token:
+        return PicoContainer._container_id_var.set(self.container_id)
+
+    def deactivate(self, token: contextvars.Token) -> None:
+        PicoContainer._container_id_var.reset(token)
+
+    @contextmanager
+    def as_current(self):
+        token = self.activate()
         try:
-            instance = run_create_chain(self._container_interceptors, ctx)
+            yield self
         finally:
-            _state._resolving.reset(tok)
-        if self._method_interceptors and not isinstance(instance, IoCProxy):
-            chain = self._method_interceptors
-            cap = getattr(self, "_method_cap", None)
-            if isinstance(cap, int) and cap >= 0:
-                chain = chain[:cap]
-            instance = IoCProxy(instance, chain, container=self, request_key=key)
-        self._singletons[key] = instance
-        return instance
+            self.deactivate(token)
 
-    def eager_instantiate_all(self):
-        for key, prov in list(self._providers.items()):
-            if not prov["lazy"]:
-                self.get(key)
+    def attach_locator(self, locator: ComponentLocator) -> None:
+        self._locator = locator
 
-    def get_all(self, base_type: Any):
-        return tuple(self._resolve_all_for_base(base_type, qualifiers=()))
+    def _cache_for(self, key: KeyT):
+        md = self._locator._metadata.get(key) if self._locator else None
+        sc = (md.scope if md else "singleton")
+        return self._caches.for_scope(self.scopes, sc)
 
-    def get_all_qualified(self, base_type: Any, *qualifiers: str):
-        return tuple(self._resolve_all_for_base(base_type, qualifiers=qualifiers))
+    def has(self, key: KeyT) -> bool:
+        cache = self._cache_for(key)
+        return cache.get(key) is not None or self._factory.has(key)
 
-    def _resolve_all_for_base(self, base_type: Any, qualifiers=()):
-        matches = []
-        for provider_key, meta in self._providers.items():
-            cls = provider_key if isinstance(provider_key, type) else None
-            if cls is None:
-                continue
-            if _requires_collection_of_base(cls, base_type):
+    @overload
+    def get(self, key: type) -> Any: ...
+    @overload
+    def get(self, key: str) -> Any: ...
+    def get(self, key: KeyT) -> Any:
+        cache = self._cache_for(key)
+        cached = cache.get(key)
+        if cached is not None:
+            self.context.cache_hit_count += 1
+            for o in self._observers: o.on_cache_hit(key)
+            return cached
+        import time as _tm
+        t0 = _tm.perf_counter()
+        chain = list(_resolve_chain.get())
+        for k in chain:
+            if k == key:
+                raise CircularDependencyError(chain, key)
+        token_chain = _resolve_chain.set(tuple(chain + [key]))
+        token_container = self.activate()
+        try:
+            if not self._factory.has(key):
+                alt = None
+                if isinstance(key, type):
+                    alt = self._resolve_type_key(key)
+                elif isinstance(key, str) and self._locator:
+                    for k, md in self._locator._metadata.items():
+                        if md.pico_name == key:
+                            alt = k
+                            break
+                if alt is not None:
+                    self._factory.bind(key, lambda a=alt: self.get(a))
+            provider = self._factory.get(key)
+            try:
+                instance = provider()
+            except ProviderNotFoundError as e:
+                raise
+            except Exception as e:
+                raise ComponentCreationError(key, e)
+            instance = self._maybe_wrap_with_aspects(key, instance)
+            cache.put(key, instance)
+            self.context.resolve_count += 1
+            took_ms = (_tm.perf_counter() - t0) * 1000
+            for o in self._observers: o.on_resolve(key, took_ms)
+            return instance
+        finally:
+            _resolve_chain.reset(token_chain)
+            self.deactivate(token_container)
+
+    async def aget(self, key: KeyT) -> Any:
+        cache = self._cache_for(key)
+        cached = cache.get(key)
+        if cached is not None:
+            self.context.cache_hit_count += 1
+            for o in self._observers: o.on_cache_hit(key)
+            return cached
+        import time as _tm
+        t0 = _tm.perf_counter()
+        chain = list(_resolve_chain.get())
+        for k in chain:
+            if k == key:
+                raise CircularDependencyError(chain, key)
+        token_chain = _resolve_chain.set(tuple(chain + [key]))
+        token_container = self.activate()
+        try:
+            if not self._factory.has(key):
+                alt = None
+                if isinstance(key, type):
+                    alt = self._resolve_type_key(key)
+                elif isinstance(key, str) and self._locator:
+                    for k, md in self._locator._metadata.items():
+                        if md.pico_name == key:
+                            alt = k
+                            break
+                if alt is not None:
+                    self._factory.bind(key, lambda a=alt: self.get(a))
+            provider = self._factory.get(key)
+            try:
+                instance = provider()
+                if inspect.isawaitable(instance):
+                    instance = await instance
+            except ProviderNotFoundError as e:
+                raise
+            except Exception as e:
+                raise ComponentCreationError(key, e)
+            instance = self._maybe_wrap_with_aspects(key, instance)
+            cache.put(key, instance)
+            self.context.resolve_count += 1
+            took_ms = (_tm.perf_counter() - t0) * 1000
+            for o in self._observers: o.on_resolve(key, took_ms)
+            return instance
+        finally:
+            _resolve_chain.reset(token_chain)
+            self.deactivate(token_container)
+
+    def _resolve_type_key(self, key: type):
+        if not self._locator:
+            return None
+        cands: List[Tuple[bool, Any]] = []
+        for k, md in self._locator._metadata.items():
+            typ = md.provided_type or md.concrete_class
+            if not isinstance(typ, type):
                 continue
-            if _is_compatible(cls, base_type):
-                prov_qs = meta.get("qualifiers", ())
-                if all(q in prov_qs for q in qualifiers):
-                    inst = self.get(provider_key)
-                    matches.append(inst)
-        return matches
-
-    def get_providers(self) -> Dict[Any, Dict]:
-        return self._providers.copy()
-
-def _is_protocol(t) -> bool:
-    return getattr(t, "_is_protocol", False) is True
-
-def _is_compatible(cls, base) -> bool:
-    try:
-        if isinstance(base, type) and issubclass(cls, base):
-            return True
-    except TypeError:
-        pass
-    if _is_protocol(base):
-        names = set(getattr(base, "__annotations__", {}).keys())
-        names.update(n for n in getattr(base, "__dict__", {}).keys() if not n.startswith("_"))
-        for n in names:
-            if n.startswith("__") and n.endswith("__"):
+            try:
+                if typ is not key and issubclass(typ, key):
+                    cands.append((md.primary, k))
+            except Exception:
                 continue
-            if not hasattr(cls, n):
-                return False
-        return True
-    return False
-
-def _requires_collection_of_base(cls, base) -> bool:
-    try:
-        sig = inspect.signature(cls.__init__)
-    except Exception:
-        return False
-    try:
-        from .resolver import _get_hints
-        hints = _get_hints(cls.__init__, owner_cls=cls)
-    except Exception:
-        hints = {}
-    for name, param in sig.parameters.items():
-        if name == "self":
-            continue
-        ann = hints.get(name, param.annotation)
-        origin = get_origin(ann) or ann
-        if origin in (list, tuple, _t.List, _t.Tuple):
-            inner = (get_args(ann) or (object,))[0]
-            if get_origin(inner) is Annotated:
-                args = get_args(inner)
-                if args:
-                    inner = args[0]
-            if inner is base:
-                return True
-    return False
+        if not cands:
+            return None
+        prim = [k for is_p, k in cands if is_p]
+        return prim[0] if prim else cands[0][1]
+
+    def _maybe_wrap_with_aspects(self, key, instance: Any) -> Any:
+        if isinstance(instance, UnifiedComponentProxy):
+            return instance
+        cls = type(instance)
+        for _, fn in inspect.getmembers(cls, predicate=lambda m: inspect.isfunction(m) or inspect.ismethod(m) or inspect.iscoroutinefunction(m)):
+            if getattr(fn, "_pico_interceptors_", None):
+                return UnifiedComponentProxy(container=self, target=instance)
+        return instance
+
+    def cleanup_all(self) -> None:
+        for _, obj in self._caches.all_items():
+            for _, m in inspect.getmembers(obj, predicate=inspect.ismethod):
+                meta = getattr(m, PICO_META, {})
+                if meta.get("cleanup", False):
+                    from .api import _resolve_args
+                    kwargs = _resolve_args(m, self)
+                    m(**kwargs)
+        if self._locator:
+            seen = set()
+            for md in self._locator._metadata.values():
+                fc = md.factory_class
+                if fc and fc not in seen:
+                    seen.add(fc)
+                    inst = self.get(fc) if self._factory.has(fc) else fc()
+                    for _, m in inspect.getmembers(inst, predicate=inspect.ismethod):
+                        meta = getattr(m, PICO_META, {})
+                        if meta.get("cleanup", False):
+                            from .api import _resolve_args
+                            kwargs = _resolve_args(m, self)
+                            m(**kwargs)
+
+    def activate_scope(self, name: str, scope_id: Any):
+        return self.scopes.activate(name, scope_id)
+
+    def deactivate_scope(self, name: str, token: Optional[contextvars.Token]) -> None:
+        self.scopes.deactivate(name, token)
+
+    def info(self, msg: str) -> None:
+        LOGGER.info(f"[{self.container_id[:8]}] {msg}")
+
+    @contextmanager
+    def scope(self, name: str, scope_id: Any):
+        tok = self.activate_scope(name, scope_id)
+        try:
+            yield self
+        finally:
+            self.deactivate_scope(name, tok)
+
+    def health_check(self) -> Dict[str, bool]:
+        out: Dict[str, bool] = {}
+        for k, obj in self._caches.all_items():
+            for name, m in inspect.getmembers(obj, predicate=callable):
+                if getattr(m, PICO_META, {}).get("health_check", False):
+                    try:
+                        out[f"{getattr(k,'__name__',k)}.{name}"] = bool(m())
+                    except Exception:
+                        out[f"{getattr(k,'__name__',k)}.{name}"] = False
+        return out
+
+    async def cleanup_all_async(self) -> None:
+        for _, obj in self._caches.all_items():
+            for _, m in inspect.getmembers(obj, predicate=inspect.ismethod):
+                meta = getattr(m, PICO_META, {})
+                if meta.get("cleanup", False):
+                    from .api import _resolve_args
+                    res = m(**_resolve_args(m, self))
+                    import inspect as _i
+                    if _i.isawaitable(res):
+                        await res
+        if self._locator:
+            seen = set()
+            for md in self._locator._metadata.values():
+                fc = md.factory_class
+                if fc and fc not in seen:
+                    seen.add(fc)
+                    inst = self.get(fc) if self._factory.has(fc) else fc()
+                    for _, m in inspect.getmembers(inst, predicate=inspect.ismethod):
+                        meta = getattr(m, PICO_META, {})
+                        if meta.get("cleanup", False):
+                            from .api import _resolve_args
+                            res = m(**_resolve_args(m, self))
+                            import inspect as _i
+                            if _i.isawaitable(res):
+                                await res
+        try:
+            from .event_bus import EventBus
+            for _, obj in self._caches.all_items():
+                if isinstance(obj, EventBus):
+                    await obj.aclose()
+        except Exception:
+            pass
+
+    def stats(self) -> Dict[str, Any]:
+        import time as _t
+        resolves = self.context.resolve_count
+        hits = self.context.cache_hit_count
+        total = resolves + hits
+        return {
+            "container_id": self.container_id,
+            "profiles": self.context.profiles,
+            "uptime_seconds": _t.time() - self.context.created_at,
+            "total_resolves": resolves,
+            "cache_hits": hits,
+            "cache_hit_rate": (hits / total) if total > 0 else 0.0,
+            "registered_components": len(self._locator._metadata) if self._locator else 0,
+        }
+
+    def shutdown(self) -> None:
+        self.cleanup_all()
+        PicoContainer._container_registry.pop(self.container_id, None)
 

pico_ioc/event_bus.py

@@ -0,0 +1,224 @@
+# src/pico_ioc/event_bus.py
+import asyncio
+import inspect
+import logging
+import threading
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Tuple, Type
+from .api import factory, provides, configure, cleanup, primary
+from .exceptions import EventBusClosedError, EventBusError, EventBusQueueFullError, EventBusHandlerError
+
+log = logging.getLogger(__name__)
+
+class ExecPolicy(Enum):
+    INLINE = auto()
+    THREADPOOL = auto()
+    TASK = auto()
+
+class ErrorPolicy(Enum):
+    LOG = auto()
+    RAISE = auto()
+
+class Event: ...
+
+@dataclass(order=True)
+class _Subscriber:
+    sort_index: int = field(init=False, repr=False, compare=True)
+    priority: int = field(compare=False)
+    callback: Callable[[Event], Any] | Callable[[Event], Awaitable[Any]] = field(compare=False)
+    policy: ExecPolicy = field(compare=False)
+    once: bool = field(compare=False)
+    def __post_init__(self):
+        self.sort_index = -int(self.priority)
+
+class EventBus:
+    def __init__(
+        self,
+        *,
+        default_exec_policy: ExecPolicy = ExecPolicy.INLINE,
+        error_policy: ErrorPolicy = ErrorPolicy.LOG,
+        max_queue_size: int = 0,
+    ):
+        self._subs: Dict[Type[Event], List[_Subscriber]] = {}
+        self._default_policy = default_exec_policy
+        self._error_policy = error_policy
+        self._queue: Optional[asyncio.Queue[Event]] = asyncio.Queue(max_queue_size) if max_queue_size >= 0 else None
+        self._worker_task: Optional[asyncio.Task] = None
+        self._worker_loop: Optional[asyncio.AbstractEventLoop] = None
+        self._closed = False
+        self._lock = threading.RLock()
+
+    def subscribe(
+        self,
+        event_type: Type[Event],
+        fn: Callable[[Event], Any] | Callable[[Event], Awaitable[Any]],
+        *,
+        priority: int = 0,
+        policy: Optional[ExecPolicy] = None,
+        once: bool = False,
+    ) -> None:
+        with self._lock:
+            if self._closed:
+                raise EventBusClosedError()
+            sub = _Subscriber(priority=priority, callback=fn, policy=policy or self._default_policy, once=once)
+            lst = self._subs.setdefault(event_type, [])
+            if any(s.callback is fn for s in lst):
+                return
+            lst.append(sub)
+            lst.sort()
+
+    def unsubscribe(self, event_type: Type[Event], fn: Callable[[Event], Any] | Callable[[Event], Awaitable[Any]]) -> None:
+        with self._lock:
+            lst = self._subs.get(event_type, [])
+            self._subs[event_type] = [s for s in lst if s.callback is not fn]
+
+    def publish_sync(self, event: Event) -> None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            asyncio.run(self.publish(event))
+            return
+        if loop.is_running():
+            async def _bridge():
+                await self.publish(event)
+            loop.create_task(_bridge())
+        else:
+            asyncio.run(self.publish(event))
+
+    async def publish(self, event: Event) -> None:
+        if self._closed:
+            raise EventBusClosedError()
+        with self._lock:
+            subs = list(self._subs.get(type(event), []))
+        to_remove: List[_Subscriber] = []
+        pending: List[asyncio.Task] = []
+        for sub in subs:
+            try:
+                cb = sub.callback
+                if inspect.iscoroutinefunction(cb):
+                    if sub.policy is ExecPolicy.TASK:
+                        pending.append(asyncio.create_task(cb(event)))
+                    else:
+                        await cb(event)
+                else:
+                    if sub.policy is ExecPolicy.THREADPOOL:
+                        loop = asyncio.get_running_loop()
+                        await loop.run_in_executor(None, cb, event)
+                    else:
+                        cb(event)
+                if sub.once:
+                    to_remove.append(sub)
+            except Exception as ex:
+                self._handle_error(EventBusHandlerError(type(event).__name__, getattr(sub.callback, "__name__", "<callback>"), ex))
+        if pending:
+            try:
+                await asyncio.gather(*pending, return_exceptions=False)
+            except Exception as ex:
+                self._handle_error(EventBusError(f"Unhandled error awaiting event tasks: {ex}"))
+        if to_remove:
+            with self._lock:
+                lst = self._subs.get(type(event), [])
+                self._subs[type(event)] = [s for s in lst if s not in to_remove]
+
+    async def start_worker(self) -> None:
+        if self._closed:
+            raise EventBusClosedError()
+        if self._worker_task:
+            return
+        if self._queue is None:
+            self._queue = asyncio.Queue()
+        loop = asyncio.get_running_loop()
+        self._worker_loop = loop
+        async def _worker():
+            while True:
+                evt = await self._queue.get()
+                if evt is None:
+                    self._queue.task_done()
+                    break
+                try:
+                    await self.publish(evt)
+                finally:
+                    self._queue.task_done()
+        self._worker_task = asyncio.create_task(_worker())
+
+    async def stop_worker(self) -> None:
+        if self._worker_task and self._queue and self._worker_loop:
+            await self._queue.put(None)
+            await self._queue.join()
+            await self._worker_task
+            self._worker_task = None
+            self._worker_loop = None
+
+    def post(self, event: Event) -> None:
+        if self._closed:
+            raise EventBusClosedError()
+        if self._queue is None:
+            raise EventBusError("Worker queue not initialized. Call start_worker().")
+        loop = self._worker_loop
+        if loop and loop.is_running():
+            try:
+                current_loop = asyncio.get_running_loop()
+                if current_loop is loop:
+                    try:
+                        self._queue.put_nowait(event)
+                        return
+                    except asyncio.QueueFull:
+                        raise EventBusQueueFullError()
+            except RuntimeError:
+                pass
+            try:
+                loop.call_soon_threadsafe(self._queue.put_nowait, event)
+                return
+            except asyncio.QueueFull:
+                raise EventBusQueueFullError()
+        else:
+            raise EventBusError("Worker queue not initialized or loop not running. Call start_worker().")
+
+    async def aclose(self) -> None:
+        await self.stop_worker()
+        with self._lock:
+            self._closed = True
+            self._subs.clear()
+
+    def _handle_error(self, ex: EventBusError) -> None:
+        if self._error_policy is ErrorPolicy.RAISE:
+            raise ex
+        if self._error_policy is ErrorPolicy.LOG:
+            log.exception("%s", ex)
+
+def subscribe(event_type: Type[Event], *, priority: int = 0, policy: ExecPolicy = ExecPolicy.INLINE, once: bool = False):
+    def dec(fn: Callable[[Event], Any] | Callable[[Event], Awaitable[Any]]):
+        subs: Iterable[Tuple[Type[Event], int, ExecPolicy, bool]] = getattr(fn, "_pico_subscriptions_", ())
+        subs = list(subs)
+        subs.append((event_type, int(priority), policy, bool(once)))
+        setattr(fn, "_pico_subscriptions_", tuple(subs))
+        return fn
+    return dec
+
+class AutoSubscriberMixin:
+    @configure
+    def _pico_autosubscribe(self, event_bus: EventBus) -> None:
+        for _, attr in inspect.getmembers(self, predicate=callable):
+            subs: Iterable[Tuple[Type[Event], int, ExecPolicy, bool]] = getattr(attr, "_pico_subscriptions_", ())
+            for evt_t, pr, pol, once in subs:
+                event_bus.subscribe(evt_t, attr, priority=pr, policy=pol, once=once)
+
+@factory
+@primary
+class PicoEventBusProvider:
+    @provides(EventBus)
+    def build(self) -> EventBus:
+        return EventBus()
+    @cleanup
+    def shutdown(self, event_bus: EventBus) -> None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            asyncio.run(event_bus.aclose())
+            return
+        if loop.is_running():
+            loop.create_task(event_bus.aclose())
+        else:
+            asyncio.run(event_bus.aclose())
+