matrix-agent 0.1.1__py3-none-any.whl

matrix_agent/__init__.py

@@ -0,0 +1,5 @@
+from .agent import MatrixAgent, AgentConfig
+from .core import BaseChain, BaseFactory
+from .handlers import MatrixHandler
+
+__all__ = ["MatrixAgent", "AgentConfig", "BaseChain", "BaseFactory", "MatrixHandler"]

matrix_agent/agent.py

@@ -0,0 +1,71 @@
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Dict, Any, Optional
+from nio import AsyncClient, AsyncClientConfig
+from nio.crypto import TrustState
+
+from .core import BaseChain
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class AgentConfig:
+    homeserver: str
+    user_id: str
+    device_id: Optional[str] = None
+    access_token: Optional[str] = None
+    store_path: str = "/tmp"
+    store_sync_tokens: bool = True
+    encryption_enabled: bool = True
+
+class MatrixAgent:
+    def __init__(self, config: AgentConfig, chain: BaseChain):
+        self.config = config
+        self.chain = chain
+        self._client: Optional[AsyncClient] = None
+
+    async def login(self):
+        client_config = AsyncClientConfig(
+            store_sync_tokens=self.config.store_sync_tokens,
+            encryption_enabled=self.config.encryption_enabled,
+        )
+        self._client = AsyncClient(
+            self.config.homeserver,
+            self.config.user_id,
+            device_id=self.config.device_id,
+            store_path=self.config.store_path,
+            config=client_config,
+        )
+
+        if not self.config.access_token:
+            raise ValueError("Access token is required for automated login.")
+
+        self._client.restore_login(
+            user_id=self.config.user_id,
+            device_id=self.config.device_id,
+            access_token=self.config.access_token,
+        )
+
+    def _callback_wrapper(self, event):
+        asyncio.create_task(self._dispatch(event))
+
+    async def _dispatch(self, event):
+        request_context = {"event": event, "client": self._client}
+        await self.chain.execute(request_context)
+
+    async def start(self):
+        await self._client.sync(full_state=True)
+        for device in self._client.device_store:
+            if device.trust_state != TrustState.verified:
+                self._client.verify_device(device)
+
+        # Register both Room and ToDevice event paths
+        self._client.add_event_callback(self._callback_wrapper)
+        self._client.add_to_device_callback(self._callback_wrapper)
+
+        await self._client.sync_forever(timeout=30_000, full_state=True)
+
+    async def close(self):
+        if self._client:
+            await self._client.close()

matrix_agent/core.py

@@ -0,0 +1,67 @@
+import importlib
+import logging
+from typing import Dict, Any, Optional, Type, List
+
+logger = logging.getLogger(__name__)
+
+class FactoryMeta(type):
+    def __call__(cls, *args, **kwargs):
+        name = args[0] if args else kwargs.get("name")
+        if cls.__name__ == "BaseFactory" and isinstance(name, str):
+            if name in cls._registry:
+                concrete_class = cls._registry[name]
+            else:
+                concrete_class = cls._lazy_load(name)
+            return super(FactoryMeta, cls).__call__(concrete_class, *args, **kwargs)
+        return super().__call__(*args, **kwargs)
+
+class BaseFactory(metaclass=FactoryMeta):
+    plugin_dir: Optional[str] = None
+    _registry: Dict[str, Type["BaseFactory"]] = {}
+
+    def __init_subclass__(cls, name: Optional[str] = None, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if name is None:
+            name = cls.__module__.split(".")[-1]
+
+        # Handle registry isolation for different factory types
+        if BaseFactory not in cls.__bases__:
+            factory_cls = cls.__bases__[0]
+            if not hasattr(factory_cls, "_registry") or factory_cls._registry is BaseFactory._registry:
+                setattr(factory_cls, "_registry", {})
+            factory_cls._registry[name] = cls
+
+    @classmethod
+    def _lazy_load(cls, name: str) -> Type["BaseFactory"]:
+        if not cls.plugin_dir:
+            raise RuntimeError(f"Factory {cls.__name__} has no 'plugin_dir' defined.")
+        try:
+            importlib.import_module(f"{cls.plugin_dir}.{name}")
+            return cls._registry[name]
+        except (ImportError, KeyError):
+            raise KeyError(f"Could not find registered implementation '{name}' in {cls.plugin_dir}")
+
+class BaseHandler:
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+
+    def can_handle(self, request: Dict[str, Any]) -> bool:
+        raise NotImplementedError
+
+    async def handle(self, request: Dict[str, Any]) -> bool:
+        raise NotImplementedError
+
+class BaseChain:
+    def __init__(self, factory: Type[BaseFactory], handler_names: List[str], global_config: Dict[str, Any]):
+        self.handlers = []
+        for name in handler_names:
+            config = global_config.get(name, {})
+            handler_cls = factory(name)
+            self.handlers.append(handler_cls(config))
+
+    async def execute(self, request: Dict[str, Any]):
+        for handler in self.handlers:
+            if handler.can_handle(request):
+                consumed = await handler.handle(request)
+                if consumed:
+                    break

matrix_agent/handlers.py

@@ -0,0 +1,16 @@
+from typing import Any
+from .core import BaseHandler
+
+class MatrixHandler(BaseHandler):
+    """
+    Abstract Base Class for Matrix Handlers.
+    The 'request' object passed to these methods always contains:
+    {'event': nio_event, 'client': nio_client}
+    """
+    def can_handle(self, request: dict) -> bool:
+        # To be overridden by concrete handlers
+        return False
+
+    async def handle(self, request: dict) -> bool:
+        # To be overridden by concrete handlers
+        return False

matrix_agent-0.1.1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: matrix-agent
+Version: 0.1.1
+Summary: Plugin-driven matrix client framework.
+Author-email: Peach <james@christhall.us>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/girrasol/matrix-bot
+Keywords: matrix,agent,bot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: matrix-nio
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+
+# Matrix Bot
+
+

matrix_agent-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+matrix_agent/__init__.py,sha256=9h0iYvIae-zddLFp2PYgEDC5oW743glYQRAeSotFvyY,208
+matrix_agent/agent.py,sha256=EFEz4jTTg8fd2SAEyD3-F28dkJtVpZ9D0clxnfURw1A,2270
+matrix_agent/core.py,sha256=8TmWZVcmMIrpcd_uE5hFV43-fBK1GeQ6VYWFwXWCWuA,2627
+matrix_agent/handlers.py,sha256=W17sQzVjUnlvFZ8ODxoMIMBToK0VhkAiptF46Hbh_vg,501
+matrix_agent-0.1.1.dist-info/METADATA,sha256=P_caHUBquxz0u8Q-qOSwk1lzEUHvxiXiz3hRO2HNvj8,757
+matrix_agent-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+matrix_agent-0.1.1.dist-info/top_level.txt,sha256=AbvkOHrhUIWo2DQLcZnQ-Lmi5tzaDUgC3HVPXuiLcto,13
+matrix_agent-0.1.1.dist-info/RECORD,,

matrix_agent-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

matrix_agent-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+matrix_agent