feed-the-machine 1.5.0 → 1.6.0

package/ftm-inbox/backend/adapters/registry.py

@@ -1,192 +1,192 @@
-"""
-AdapterRegistry — loads and manages poller adapters from config.yml.
-
-Config format (see config.example.yml):
-
-    adapters:
-      - name: jira
-        class: ftm_inbox.adapters.jira.JiraAdapter
-        interval_seconds: 60
-        credentials:
-          api_token: "..."
-          email: "..."
-        config:
-          base_url: "https://myorg.atlassian.net"
-          project_key: "OPS"
-
-The registry uses importlib to load adapter classes by dotted module path,
-validates that each class is a subclass of BaseAdapter, and confirms that
-credentials are present (non-empty) before registering the adapter.
-"""
-
-import importlib
-import logging
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from .base import BaseAdapter
-
-logger = logging.getLogger(__name__)
-
-_DEFAULT_CONFIG_PATH = (
-    Path(__file__).resolve().parent.parent.parent / "config.yml"
-)
-
-
-class AdapterRegistryError(Exception):
-    """Raised when an adapter cannot be loaded or validated."""
-
-
-class AdapterRegistry:
-    """
-    Loads adapter definitions from config.yml and instantiates each one.
-
-    Usage:
-        registry = AdapterRegistry.from_config()
-        for adapter in registry.adapters:
-            adapter.run_cycle(conn)
-    """
-
-    def __init__(self) -> None:
-        self._adapters: list[BaseAdapter] = []
-
-    @property
-    def adapters(self) -> list[BaseAdapter]:
-        return list(self._adapters)
-
-    @classmethod
-    def from_config(
-        cls, config_path: Path | None = None
-    ) -> "AdapterRegistry":
-        """
-        Build a registry from a YAML config file.
-
-        Args:
-            config_path: Path to config.yml. Defaults to <project_root>/config.yml.
-
-        Returns:
-            Populated AdapterRegistry.
-
-        Raises:
-            AdapterRegistryError: If the config file is missing or an adapter
-                                  fails validation.
-        """
-        path = config_path or _DEFAULT_CONFIG_PATH
-
-        if not path.exists():
-            logger.warning(
-                "config.yml not found at %s — no adapters registered.", path
-            )
-            return cls()
-
-        with path.open() as fh:
-            raw = yaml.safe_load(fh) or {}
-
-        adapter_defs: list[dict[str, Any]] = raw.get("adapters", [])
-        registry = cls()
-
-        for definition in adapter_defs:
-            try:
-                adapter = _load_adapter(definition)
-                registry._adapters.append(adapter)
-                logger.info(
-                    "Registered adapter '%s' (%s)",
-                    definition.get("name"),
-                    definition.get("class"),
-                )
-            except AdapterRegistryError as exc:
-                logger.error("Skipping adapter '%s': %s", definition.get("name"), exc)
-
-        return registry
-
-    def get(self, name: str) -> BaseAdapter | None:
-        """Return a registered adapter by name, or None."""
-        for adapter in self._adapters:
-            if adapter.source_name == name:
-                return adapter
-        return None
-
-    def __len__(self) -> int:
-        return len(self._adapters)
-
-    def __repr__(self) -> str:
-        names = [a.source_name for a in self._adapters]
-        return f"AdapterRegistry(adapters={names})"
-
-
-def _load_adapter(definition: dict[str, Any]) -> BaseAdapter:
-    """
-    Instantiate a single adapter from its config definition.
-
-    Validates:
-      - 'class' key is present and is a valid dotted path
-      - The resolved class is a subclass of BaseAdapter
-      - Required credentials keys are present and non-empty
-
-    Raises:
-        AdapterRegistryError on any validation failure.
-    """
-    dotted_path: str = definition.get("class", "")
-    if not dotted_path:
-        raise AdapterRegistryError("Missing 'class' key in adapter definition.")
-
-    module_path, _, class_name = dotted_path.rpartition(".")
-    if not module_path:
-        raise AdapterRegistryError(
-            f"'class' must be a dotted path (got '{dotted_path}')."
-        )
-
-    try:
-        module = importlib.import_module(module_path)
-    except ImportError as exc:
-        raise AdapterRegistryError(
-            f"Cannot import module '{module_path}': {exc}"
-        ) from exc
-
-    klass = getattr(module, class_name, None)
-    if klass is None:
-        raise AdapterRegistryError(
-            f"Class '{class_name}' not found in module '{module_path}'."
-        )
-
-    if not (isinstance(klass, type) and issubclass(klass, BaseAdapter)):
-        raise AdapterRegistryError(
-            f"'{dotted_path}' is not a subclass of BaseAdapter."
-        )
-
-    credentials: dict[str, Any] = definition.get("credentials", {}) or {}
-    config: dict[str, Any] = definition.get("config", {}) or {}
-
-    _validate_credentials(definition.get("name", dotted_path), credentials, klass)
-
-    instance = klass(credentials=credentials, config=config)
-    # Allow the class to declare its source_name via class attribute;
-    # fall back to the 'name' key in the config definition.
-    if not instance.source_name:
-        instance.source_name = definition.get("name", class_name.lower())
-
-    return instance
-
-
-def _validate_credentials(
-    adapter_name: str,
-    credentials: dict[str, Any],
-    klass: type,
-) -> None:
-    """
-    Check that all keys declared in klass.required_credentials are present
-    and non-empty in the credentials dict.
-
-    Adapters opt into this by setting a class-level list:
-        required_credentials = ["api_token", "email"]
-
-    If the class doesn't declare required_credentials, skip validation.
-    """
-    required: list[str] = getattr(klass, "required_credentials", [])
-    missing = [key for key in required if not credentials.get(key)]
-    if missing:
-        raise AdapterRegistryError(
-            f"Adapter '{adapter_name}' missing required credentials: {missing}"
-        )
+"""
+AdapterRegistry — loads and manages poller adapters from config.yml.
+
+Config format (see config.example.yml):
+
+    adapters:
+      - name: jira
+        class: ftm_inbox.adapters.jira.JiraAdapter
+        interval_seconds: 60
+        credentials:
+          api_token: "..."
+          email: "..."
+        config:
+          base_url: "https://myorg.atlassian.net"
+          project_key: "OPS"
+
+The registry uses importlib to load adapter classes by dotted module path,
+validates that each class is a subclass of BaseAdapter, and confirms that
+credentials are present (non-empty) before registering the adapter.
+"""
+
+import importlib
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .base import BaseAdapter
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_CONFIG_PATH = (
+    Path(__file__).resolve().parent.parent.parent / "config.yml"
+)
+
+
+class AdapterRegistryError(Exception):
+    """Raised when an adapter cannot be loaded or validated."""
+
+
+class AdapterRegistry:
+    """
+    Loads adapter definitions from config.yml and instantiates each one.
+
+    Usage:
+        registry = AdapterRegistry.from_config()
+        for adapter in registry.adapters:
+            adapter.run_cycle(conn)
+    """
+
+    def __init__(self) -> None:
+        self._adapters: list[BaseAdapter] = []
+
+    @property
+    def adapters(self) -> list[BaseAdapter]:
+        return list(self._adapters)
+
+    @classmethod
+    def from_config(
+        cls, config_path: Path | None = None
+    ) -> "AdapterRegistry":
+        """
+        Build a registry from a YAML config file.
+
+        Args:
+            config_path: Path to config.yml. Defaults to <project_root>/config.yml.
+
+        Returns:
+            Populated AdapterRegistry.
+
+        Raises:
+            AdapterRegistryError: If the config file is missing or an adapter
+                                  fails validation.
+        """
+        path = config_path or _DEFAULT_CONFIG_PATH
+
+        if not path.exists():
+            logger.warning(
+                "config.yml not found at %s — no adapters registered.", path
+            )
+            return cls()
+
+        with path.open() as fh:
+            raw = yaml.safe_load(fh) or {}
+
+        adapter_defs: list[dict[str, Any]] = raw.get("adapters", [])
+        registry = cls()
+
+        for definition in adapter_defs:
+            try:
+                adapter = _load_adapter(definition)
+                registry._adapters.append(adapter)
+                logger.info(
+                    "Registered adapter '%s' (%s)",
+                    definition.get("name"),
+                    definition.get("class"),
+                )
+            except AdapterRegistryError as exc:
+                logger.error("Skipping adapter '%s': %s", definition.get("name"), exc)
+
+        return registry
+
+    def get(self, name: str) -> BaseAdapter | None:
+        """Return a registered adapter by name, or None."""
+        for adapter in self._adapters:
+            if adapter.source_name == name:
+                return adapter
+        return None
+
+    def __len__(self) -> int:
+        return len(self._adapters)
+
+    def __repr__(self) -> str:
+        names = [a.source_name for a in self._adapters]
+        return f"AdapterRegistry(adapters={names})"
+
+
+def _load_adapter(definition: dict[str, Any]) -> BaseAdapter:
+    """
+    Instantiate a single adapter from its config definition.
+
+    Validates:
+      - 'class' key is present and is a valid dotted path
+      - The resolved class is a subclass of BaseAdapter
+      - Required credentials keys are present and non-empty
+
+    Raises:
+        AdapterRegistryError on any validation failure.
+    """
+    dotted_path: str = definition.get("class", "")
+    if not dotted_path:
+        raise AdapterRegistryError("Missing 'class' key in adapter definition.")
+
+    module_path, _, class_name = dotted_path.rpartition(".")
+    if not module_path:
+        raise AdapterRegistryError(
+            f"'class' must be a dotted path (got '{dotted_path}')."
+        )
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as exc:
+        raise AdapterRegistryError(
+            f"Cannot import module '{module_path}': {exc}"
+        ) from exc
+
+    klass = getattr(module, class_name, None)
+    if klass is None:
+        raise AdapterRegistryError(
+            f"Class '{class_name}' not found in module '{module_path}'."
+        )
+
+    if not (isinstance(klass, type) and issubclass(klass, BaseAdapter)):
+        raise AdapterRegistryError(
+            f"'{dotted_path}' is not a subclass of BaseAdapter."
+        )
+
+    credentials: dict[str, Any] = definition.get("credentials", {}) or {}
+    config: dict[str, Any] = definition.get("config", {}) or {}
+
+    _validate_credentials(definition.get("name", dotted_path), credentials, klass)
+
+    instance = klass(credentials=credentials, config=config)
+    # Allow the class to declare its source_name via class attribute;
+    # fall back to the 'name' key in the config definition.
+    if not instance.source_name:
+        instance.source_name = definition.get("name", class_name.lower())
+
+    return instance
+
+
+def _validate_credentials(
+    adapter_name: str,
+    credentials: dict[str, Any],
+    klass: type,
+) -> None:
+    """
+    Check that all keys declared in klass.required_credentials are present
+    and non-empty in the credentials dict.
+
+    Adapters opt into this by setting a class-level list:
+        required_credentials = ["api_token", "email"]
+
+    If the class doesn't declare required_credentials, skip validation.
+    """
+    required: list[str] = getattr(klass, "required_credentials", [])
+    missing = [key for key in required if not credentials.get(key)]
+    if missing:
+        raise AdapterRegistryError(
+            f"Adapter '{adapter_name}' missing required credentials: {missing}"
+        )

package/ftm-inbox/backend/adapters/slack.py

@@ -1,110 +1,110 @@
-"""
-SlackAdapter — polls Slack channels for recent messages.
-
-Required credentials:
-    bot_token   Slack bot token (xoxb-...)
-
-Config keys:
-    channels        List of channel IDs to poll
-    lookback_hours  How far back to fetch messages, default 24
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-from typing import Any
-
-import requests
-
-from backend.adapters._retry import retry
-from backend.adapters.base import BaseAdapter, NormalizedItem
-
-logger = logging.getLogger(__name__)
-
-
-class SlackAdapter(BaseAdapter):
-    """Polls Slack channels for recent messages."""
-
-    source_name = "slack"
-    required_credentials = ["bot_token"]
-
-    def __init__(self, credentials: dict, config: dict) -> None:
-        super().__init__(credentials, config)
-        self._token = credentials["bot_token"]
-        self._channels: list[str] = config.get("channels", [])
-        self._lookback_hours = int(config.get("lookback_hours", 24))
-        self._headers = {
-            "Authorization": f"Bearer {self._token}",
-            "Content-Type": "application/json",
-        }
-
-    @retry(max_attempts=3, base_delay=1.0, exceptions=(requests.RequestException,))
-    def poll(self) -> list[dict]:
-        """Fetch recent messages from configured Slack channels."""
-        oldest = str(time.time() - self._lookback_hours * 3600)
-        all_messages: list[dict] = []
-
-        for channel_id in self._channels:
-            url = "https://slack.com/api/conversations.history"
-            params: dict[str, Any] = {
-                "channel": channel_id,
-                "oldest": oldest,
-                "limit": 200,
-            }
-            response = requests.get(
-                url, headers=self._headers, params=params, timeout=30
-            )
-            response.raise_for_status()
-            data = response.json()
-
-            if not data.get("ok"):
-                logger.warning(
-                    "Slack API error for channel %s: %s",
-                    channel_id,
-                    data.get("error", "unknown"),
-                )
-                continue
-
-            messages = data.get("messages", [])
-            for msg in messages:
-                msg["_channel_id"] = channel_id
-            all_messages.extend(messages)
-
-        return all_messages
-
-    def normalize(self, raw_item: dict) -> NormalizedItem:
-        """Map a Slack message dict to NormalizedItem."""
-        ts = raw_item.get("ts", "")
-        channel_id = raw_item.get("_channel_id", "")
-        text = raw_item.get("text") or ""
-
-        title = text[:100].replace("\n", " ") if text else "(no text)"
-        body = text
-
-        user = raw_item.get("user") or raw_item.get("bot_id") or "unknown"
-
-        created_at = ts
-
-        source_url = (
-            f"https://slack.com/archives/{channel_id}/p{ts.replace('.', '')}"
-            if channel_id and ts
-            else None
-        )
-
-        return NormalizedItem(
-            source=self.source_name,
-            source_id=f"{channel_id}:{ts}",
-            title=title,
-            body=body,
-            status="open",
-            priority="medium",
-            assignee=None,
-            requester=user,
-            created_at=created_at,
-            updated_at=None,
-            tags=[],
-            custom_fields={"channel_id": channel_id},
-            raw_payload=raw_item,
-            source_url=source_url,
-        )
+"""
+SlackAdapter — polls Slack channels for recent messages.
+
+Required credentials:
+    bot_token   Slack bot token (xoxb-...)
+
+Config keys:
+    channels        List of channel IDs to poll
+    lookback_hours  How far back to fetch messages, default 24
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+import requests
+
+from backend.adapters._retry import retry
+from backend.adapters.base import BaseAdapter, NormalizedItem
+
+logger = logging.getLogger(__name__)
+
+
+class SlackAdapter(BaseAdapter):
+    """Polls Slack channels for recent messages."""
+
+    source_name = "slack"
+    required_credentials = ["bot_token"]
+
+    def __init__(self, credentials: dict, config: dict) -> None:
+        super().__init__(credentials, config)
+        self._token = credentials["bot_token"]
+        self._channels: list[str] = config.get("channels", [])
+        self._lookback_hours = int(config.get("lookback_hours", 24))
+        self._headers = {
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/json",
+        }
+
+    @retry(max_attempts=3, base_delay=1.0, exceptions=(requests.RequestException,))
+    def poll(self) -> list[dict]:
+        """Fetch recent messages from configured Slack channels."""
+        oldest = str(time.time() - self._lookback_hours * 3600)
+        all_messages: list[dict] = []
+
+        for channel_id in self._channels:
+            url = "https://slack.com/api/conversations.history"
+            params: dict[str, Any] = {
+                "channel": channel_id,
+                "oldest": oldest,
+                "limit": 200,
+            }
+            response = requests.get(
+                url, headers=self._headers, params=params, timeout=30
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            if not data.get("ok"):
+                logger.warning(
+                    "Slack API error for channel %s: %s",
+                    channel_id,
+                    data.get("error", "unknown"),
+                )
+                continue
+
+            messages = data.get("messages", [])
+            for msg in messages:
+                msg["_channel_id"] = channel_id
+            all_messages.extend(messages)
+
+        return all_messages
+
+    def normalize(self, raw_item: dict) -> NormalizedItem:
+        """Map a Slack message dict to NormalizedItem."""
+        ts = raw_item.get("ts", "")
+        channel_id = raw_item.get("_channel_id", "")
+        text = raw_item.get("text") or ""
+
+        title = text[:100].replace("\n", " ") if text else "(no text)"
+        body = text
+
+        user = raw_item.get("user") or raw_item.get("bot_id") or "unknown"
+
+        created_at = ts
+
+        source_url = (
+            f"https://slack.com/archives/{channel_id}/p{ts.replace('.', '')}"
+            if channel_id and ts
+            else None
+        )
+
+        return NormalizedItem(
+            source=self.source_name,
+            source_id=f"{channel_id}:{ts}",
+            title=title,
+            body=body,
+            status="open",
+            priority="medium",
+            assignee=None,
+            requester=user,
+            created_at=created_at,
+            updated_at=None,
+            tags=[],
+            custom_fields={"channel_id": channel_id},
+            raw_payload=raw_item,
+            source_url=source_url,
+        )