Initial Commit

registry.py

@@ -0,0 +1,102 @@
+from typing import Protocol, runtime_checkable, Optional
+
+from psycopg import AsyncConnection
+
+from .connector import Connector, Connectable
+
+
+@runtime_checkable
+class _Attachable(Connectable, Protocol):
+    def attach_to(self, registry: 'Registry'):
+        raise NotImplementedError
+
+
+class Registry:
+    _attached: list[_Attachable] = []
+    _name: Optional[str] = None
+
+    def __init_subclass__(cls, name=None):
+        attached = []
+        for _, member in cls.__dict__.items():
+            if isinstance(member, _Attachable):
+                attached.append(member)
+        cls._attached = attached
+        cls._name = name or cls.__name__
+
+    def __init__(self, name=None):
+        self._conn: Optional[Connector] = None
+        self.name: str = name if name is not None else self._name
+        if self.name is None:
+            raise ValueError("A Registry must have a name!")
+
+        self.init_tasks = []
+
+        for member in self._attached:
+            member.attach_to(self)
+
+    def bind(self, connector: Connector):
+        self._conn = connector
+        for child in self._attached:
+            child.bind(connector)
+
+    def attach(self, attachable):
+        self._attached.append(attachable)
+        if self._conn is not None:
+            attachable.bind(self._conn)
+        return attachable
+
+    def init_task(self, coro):
+        """
+        Initialisation tasks are run to setup the registry state.
+        These tasks will be run in the event loop, after connection to the database.
+        These tasks should be idempotent, as they may be run on reload and reconnect.
+        """
+        self.init_tasks.append(coro)
+        return coro
+
+    async def init(self):
+        for task in self.init_tasks:
+            await task(self)
+        return self
+
+
+class AttachableClass:
+    """ABC for a default implementation of an Attachable class."""
+
+    _connector: Optional[Connector] = None
+    _registry: Optional[Registry] = None
+
+    @classmethod
+    def bind(cls, connector: Connector):
+        cls._connector = connector
+        connector.connect_hook(cls.on_connect)
+        return cls
+
+    @classmethod
+    def attach_to(cls, registry: Registry):
+        cls._registry = registry
+        return cls
+
+    @classmethod
+    async def on_connect(cls, connection: AsyncConnection):
+        pass
+
+
+class Attachable:
+    """ABC for a default implementation of an Attachable object."""
+
+    def __init__(self, *args, **kwargs):
+        self._connector: Optional[Connector] = None
+        self._registry: Optional[Registry] = None
+
+    def bind(self, connector: Connector):
+        self._connector = connector
+        connector.connect_hook(self.on_connect)
+        return self
+
+    def attach_to(self, registry: Registry):
+        self._registry = registry
+        return self
+
+    async def on_connect(self, connection: AsyncConnection):
+        pass