hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/data/postgres.py

@@ -0,0 +1,182 @@
+"""PostgresConnector — PostgreSQL database integration."""
+
+from __future__ import annotations
+
+import logging
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+    ConnectorUnavailableError,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.postgres")
+
+
+class PostgresConnector(BaseConnector):
+    """
+    PostgreSQL database connector using asyncpg.
+
+    Required config:
+        - connection_string: PostgreSQL connection URL
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.connection_string = config.get("connection_string", "")
+
+        if config.get("enabled", False) and not self.connection_string:
+            raise ValueError("PostgresConnector requires connection_string")
+
+        self._pool = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="postgres",
+            platform="postgres",
+            category="data",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                ]
+            ),
+            auth_type="api_key",
+            rate_limit_per_minute=1000,
+        )
+
+    async def _ensure_pool(self):
+        """Ensure connection pool is created."""
+        if self._pool is None:
+            try:
+                import asyncpg
+            except ImportError:
+                raise ConnectorUnavailableError("asyncpg not installed")
+
+            self._pool = await asyncpg.create_pool(
+                self.connection_string,
+                min_size=1,
+                max_size=10,
+            )
+
+    async def health(self) -> bool:
+        """Check if PostgreSQL connection is available."""
+        try:
+            import asyncpg  # noqa: F401
+        except ImportError:
+            return False
+
+        try:
+            await self._ensure_pool()
+            async with self._pool.acquire() as conn:
+                await conn.fetchval("SELECT 1")
+            return True
+        except Exception as e:
+            logger.error(f"PostgreSQL health check failed: {e}")
+            return False
+
+    async def query(self, sql: str, params: list | None = None) -> list[dict]:
+        """Execute a SQL query and return results."""
+        try:
+            import asyncpg  # noqa: F401
+        except ImportError:
+            raise ConnectorUnavailableError("asyncpg not installed")
+
+        await self._ensure_pool()
+
+        async with self._pool.acquire() as conn:
+            if params:
+                rows = await conn.fetch(sql, *params)
+            else:
+                rows = await conn.fetch(sql)
+
+            return [dict(row) for row in rows]
+
+    async def execute(self, sql: str, params: list | None = None) -> dict:
+        """Execute a SQL statement (INSERT/UPDATE/DELETE)."""
+        try:
+            import asyncpg  # noqa: F401
+        except ImportError:
+            raise ConnectorUnavailableError("asyncpg not installed")
+
+        await self._ensure_pool()
+
+        async with self._pool.acquire() as conn:
+            if params:
+                result = await conn.execute(sql, *params)
+            else:
+                result = await conn.execute(sql)
+
+            return {"status": result}
+
+    async def list_tables(self) -> list[dict]:
+        """List all tables in the database."""
+        sql = """
+            SELECT table_name, table_type
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+            ORDER BY table_name
+        """
+        return await self.query(sql)
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a row by ID."""
+        table = kwargs.get("table", "")
+        if not table:
+            raise ValueError("table parameter required")
+
+        result = await self.query(
+            f"SELECT * FROM {table} WHERE id = $1",
+            [resource_id],
+        )
+        return result[0] if result else {}
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Insert a row."""
+        columns = ", ".join(data.keys())
+        placeholders = ", ".join(f"${i+1}" for i in range(len(data)))
+        values = list(data.values())
+
+        result = await self.query(
+            f"INSERT INTO {resource_type} ({columns}) VALUES ({placeholders}) RETURNING *",
+            values,
+        )
+        return result[0] if result else {}
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Delete a row."""
+        table = kwargs.get("table", "")
+        if not table:
+            raise ValueError("table parameter required")
+
+        await self.execute(
+            f"DELETE FROM {table} WHERE id = $1",
+            [resource_id],
+        )
+        return True
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List rows from a table."""
+        sql = f"SELECT * FROM {resource_type}"
+
+        if filters:
+            conditions = []
+            params = []
+            for i, (key, value) in enumerate(filters.items()):
+                conditions.append(f"{key} = ${i+1}")
+                params.append(value)
+            sql += " WHERE " + " AND ".join(conditions)
+            return await self.query(sql, params)
+
+        return await self.query(sql)
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Execute a raw SQL query."""
+        return await self.query(query)

integrations/data/supabase_connector.py

@@ -0,0 +1,202 @@
+"""SupabaseConnector — Supabase database integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.supabase")
+
+
+class SupabaseConnector(BaseConnector):
+    """
+    Supabase database connector.
+
+    Required config:
+        - url: Supabase project URL
+        - service_role_key: Supabase service role key
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.url = config.get("url", "").rstrip("/")
+        self.service_role_key = config.get("service_role_key", "")
+
+        if config.get("enabled", False):
+            if not self.url or not self.service_role_key:
+                raise ValueError(
+                    "SupabaseConnector requires url and service_role_key"
+                )
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="supabase",
+            platform="supabase",
+            category="data",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                ]
+            ),
+            auth_type="api_key",
+            rate_limit_per_minute=60,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={
+                    "apikey": self.service_role_key,
+                    "Authorization": f"Bearer {self.service_role_key}",
+                    "Content-Type": "application/json",
+                    "Prefer": "return=representation",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Supabase API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.url}/rest/v1/")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Supabase health check failed: {e}")
+            return False
+
+    async def query(self, table: str, filters: dict | None = None) -> list[dict]:
+        """Query a table with optional filters."""
+        client = await self._get_client()
+
+        url = f"{self.url}/rest/v1/{table}"
+        params = {}
+
+        if filters:
+            for key, value in filters.items():
+                params[key] = f"eq.{value}"
+
+        response = await client.get(url, params=params)
+
+        if response.status_code != 200:
+            raise Exception(f"Supabase query failed: {response.text}")
+
+        return response.json()
+
+    async def insert(self, table: str, data: dict) -> dict:
+        """Insert a row into a table."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.url}/rest/v1/{table}",
+            json=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Supabase insert failed: {response.text}")
+
+        result = response.json()
+        return result[0] if isinstance(result, list) else result
+
+    async def update(self, table: str, id: str, data: dict) -> dict:
+        """Update a row in a table."""
+        client = await self._get_client()
+
+        response = await client.patch(
+            f"{self.url}/rest/v1/{table}",
+            params={"id": f"eq.{id}"},
+            json=data,
+        )
+
+        if response.status_code not in (200, 204):
+            raise Exception(f"Supabase update failed: {response.text}")
+
+        result = response.json()
+        return result[0] if isinstance(result, list) and result else {}
+
+    async def delete(self, table: str, id: str) -> bool:
+        """Delete a row from a table."""
+        client = await self._get_client()
+
+        response = await client.delete(
+            f"{self.url}/rest/v1/{table}",
+            params={"id": f"eq.{id}"},
+        )
+
+        if response.status_code not in (200, 204):
+            raise Exception(f"Supabase delete failed: {response.text}")
+
+        return True
+
+    async def rpc(self, function_name: str, params: dict | None = None) -> dict:
+        """Call a Supabase RPC function."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.url}/rest/v1/rpc/{function_name}",
+            json=params or {},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Supabase rpc failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a row by ID."""
+        table = kwargs.get("table", "")
+        if not table:
+            raise ValueError("table parameter required")
+
+        result = await self.query(table, {"id": resource_id})
+        return result[0] if result else {}
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Insert a row."""
+        return await self.insert(resource_type, data)
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Delete a row."""
+        table = kwargs.get("table", "")
+        if not table:
+            raise ValueError("table parameter required")
+
+        return await self.delete(table, resource_id)
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List rows from a table."""
+        return await self.query(resource_type, filters)
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search using RPC or full-text search."""
+        table = kwargs.get("table", "")
+        column = kwargs.get("column", "")
+
+        if table and column:
+            # Use PostgREST full-text search
+            client = await self._get_client()
+            response = await client.get(
+                f"{self.url}/rest/v1/{table}",
+                params={column: f"ilike.*{query}*"},
+            )
+            if response.status_code == 200:
+                return response.json()
+
+        # Fallback to RPC if available
+        return await self.rpc("search", {"query": query})