hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/productivity/google/docs.py

@@ -0,0 +1,202 @@
+"""GoogleDocsConnector — Google Docs API integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+from integrations.productivity.google.base import GoogleOAuthBase
+
+logger = logging.getLogger("hyperclaw.integrations.google_docs")
+
+
+class GoogleDocsConnector(BaseConnector, GoogleOAuthBase):
+    """
+    Google Docs API connector.
+
+    Required config (via GoogleOAuthBase):
+        - access_token or credentials_file
+    """
+
+    BASE_URL = "https://docs.googleapis.com/v1"
+    DRIVE_URL = "https://www.googleapis.com/drive/v3"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self._init_google_auth(config)
+        self._validate_google_config(config)
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="google_docs",
+            platform="google_docs",
+            category="productivity",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.ACTION,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=60,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        return await self._get_google_client()
+
+    async def health(self) -> bool:
+        """Check if Docs API is accessible."""
+        try:
+            client = await self._get_client()
+            # Use Drive API to check access since Docs doesn't have a simple endpoint
+            response = await client.get(
+                f"{self.DRIVE_URL}/about",
+                params={"fields": "user"},
+            )
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Google Docs health check failed: {e}")
+            return False
+
+    async def get_document(self, document_id: str) -> dict:
+        """Get a document's content and metadata."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/documents/{document_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"Docs get document failed: {response.text}")
+
+        return response.json()
+
+    async def create_document(
+        self,
+        title: str,
+        content: str = "",
+    ) -> dict:
+        """Create a new document."""
+        client = await self._get_client()
+
+        # Create empty document
+        response = await client.post(
+            f"{self.BASE_URL}/documents",
+            json={"title": title},
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Docs create document failed: {response.text}")
+
+        doc = response.json()
+
+        # If content provided, append it
+        if content:
+            await self.append_text(doc["documentId"], content)
+
+        return doc
+
+    async def append_text(
+        self,
+        document_id: str,
+        text: str,
+    ) -> dict:
+        """Append text to a document."""
+        client = await self._get_client()
+
+        requests = [
+            {
+                "insertText": {
+                    "location": {"index": 1},
+                    "text": text,
+                }
+            }
+        ]
+
+        response = await client.post(
+            f"{self.BASE_URL}/documents/{document_id}:batchUpdate",
+            json={"requests": requests},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Docs append text failed: {response.text}")
+
+        return response.json()
+
+    async def replace_text(
+        self,
+        document_id: str,
+        find: str,
+        replace: str,
+    ) -> dict:
+        """Replace text in a document."""
+        client = await self._get_client()
+
+        requests = [
+            {
+                "replaceAllText": {
+                    "containsText": {"text": find, "matchCase": True},
+                    "replaceText": replace,
+                }
+            }
+        ]
+
+        response = await client.post(
+            f"{self.BASE_URL}/documents/{document_id}:batchUpdate",
+            json={"requests": requests},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Docs replace text failed: {response.text}")
+
+        return response.json()
+
+    async def export_as_pdf(self, document_id: str) -> bytes:
+        """Export document as PDF."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.DRIVE_URL}/files/{document_id}/export",
+            params={"mimeType": "application/pdf"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Docs export as PDF failed: {response.text}")
+
+        return response.content
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a document."""
+        return await self.get_document(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Create a document."""
+        return await self.create_document(
+            title=data.get("title", "Untitled"),
+            content=data.get("content", ""),
+        )
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Docs-specific actions."""
+        if action_name == "append_text":
+            return await self.append_text(
+                params["document_id"],
+                params["text"],
+            )
+        elif action_name == "replace_text":
+            return await self.replace_text(
+                params["document_id"],
+                params["find"],
+                params["replace"],
+            )
+        elif action_name == "export_pdf":
+            pdf_bytes = await self.export_as_pdf(params["document_id"])
+            return {"size": len(pdf_bytes), "format": "pdf"}
+
+        raise ValueError(f"Unknown action: {action_name}")

integrations/productivity/google/drive.py

@@ -0,0 +1,268 @@
+"""GoogleDriveConnector — Google Drive API integration."""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+from pathlib import Path
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+from integrations.productivity.google.base import GoogleOAuthBase
+
+logger = logging.getLogger("hyperclaw.integrations.google_drive")
+
+
+class GoogleDriveConnector(BaseConnector, GoogleOAuthBase):
+    """
+    Google Drive API connector.
+
+    Required config (via GoogleOAuthBase):
+        - access_token or credentials_file
+    """
+
+    BASE_URL = "https://www.googleapis.com/drive/v3"
+    UPLOAD_URL = "https://www.googleapis.com/upload/drive/v3"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self._init_google_auth(config)
+        self._validate_google_config(config)
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="google_drive",
+            platform="google_drive",
+            category="productivity",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.FILE_DOWNLOAD,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=100,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        return await self._get_google_client()
+
+    async def health(self) -> bool:
+        """Check if Drive API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.BASE_URL}/about", params={"fields": "user"})
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Google Drive health check failed: {e}")
+            return False
+
+    async def upload_file(
+        self,
+        path: str,
+        folder_id: str | None = None,
+        mime_type: str | None = None,
+    ) -> dict:
+        """Upload a file to Google Drive."""
+        client = await self._get_client()
+
+        file_path = Path(path)
+        if not mime_type:
+            mime_type = mimetypes.guess_type(str(file_path))[0] or "application/octet-stream"
+
+        metadata = {"name": file_path.name}
+        if folder_id:
+            metadata["parents"] = [folder_id]
+
+        with open(path, "rb") as f:
+            content = f.read()
+
+        # Use multipart upload
+        response = await client.post(
+            f"{self.UPLOAD_URL}/files",
+            params={"uploadType": "multipart"},
+            files={
+                "metadata": ("metadata", str(metadata).encode(), "application/json"),
+                "file": (file_path.name, content, mime_type),
+            },
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Drive upload failed: {response.text}")
+
+        return response.json()
+
+    async def download_file(
+        self,
+        file_id: str,
+        destination: str,
+    ) -> str:
+        """Download a file from Google Drive."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/files/{file_id}",
+            params={"alt": "media"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Drive download failed: {response.text}")
+
+        with open(destination, "wb") as f:
+            f.write(response.content)
+
+        return destination
+
+    async def list_folder(
+        self,
+        folder_id: str = "root",
+        page_size: int = 100,
+    ) -> list[dict]:
+        """List files in a folder."""
+        client = await self._get_client()
+
+        query = f"'{folder_id}' in parents and trashed=false"
+
+        response = await client.get(
+            f"{self.BASE_URL}/files",
+            params={
+                "q": query,
+                "pageSize": page_size,
+                "fields": "files(id,name,mimeType,size,createdTime,modifiedTime)",
+            },
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Drive list folder failed: {response.text}")
+
+        return response.json().get("files", [])
+
+    async def search_files(self, query: str) -> list[dict]:
+        """Search for files."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/files",
+            params={
+                "q": f"name contains '{query}' and trashed=false",
+                "pageSize": 50,
+                "fields": "files(id,name,mimeType,size,createdTime,modifiedTime)",
+            },
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Drive search failed: {response.text}")
+
+        return response.json().get("files", [])
+
+    async def create_folder(
+        self,
+        name: str,
+        parent_id: str | None = None,
+    ) -> dict:
+        """Create a folder."""
+        client = await self._get_client()
+
+        metadata = {
+            "name": name,
+            "mimeType": "application/vnd.google-apps.folder",
+        }
+        if parent_id:
+            metadata["parents"] = [parent_id]
+
+        response = await client.post(
+            f"{self.BASE_URL}/files",
+            json=metadata,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Drive create folder failed: {response.text}")
+
+        return response.json()
+
+    async def share_file(
+        self,
+        file_id: str,
+        email: str,
+        role: str = "reader",
+    ) -> dict:
+        """Share a file with a user."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/files/{file_id}/permissions",
+            json={
+                "type": "user",
+                "role": role,
+                "emailAddress": email,
+            },
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Drive share failed: {response.text}")
+
+        return response.json()
+
+    async def get_file_metadata(self, file_id: str) -> dict:
+        """Get file metadata."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/files/{file_id}",
+            params={"fields": "id,name,mimeType,size,createdTime,modifiedTime,owners,permissions"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Drive get metadata failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read file metadata."""
+        return await self.get_file_metadata(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Create a file or folder."""
+        if resource_type == "folder":
+            return await self.create_folder(
+                name=data.get("name", "Untitled"),
+                parent_id=data.get("parent_id"),
+            )
+        else:
+            return await self.upload_file(
+                path=data.get("path"),
+                folder_id=data.get("folder_id"),
+                mime_type=data.get("mime_type"),
+            )
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Delete a file."""
+        client = await self._get_client()
+
+        response = await client.delete(f"{self.BASE_URL}/files/{resource_id}")
+
+        return response.status_code == 204
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List files."""
+        return await self.list_folder(
+            folder_id=filters.get("folder_id", "root"),
+            page_size=filters.get("page_size", 100),
+        )
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search files."""
+        return await self.search_files(query)