alwrity chatbot assistant, content scheduler, and content repurposing

lib/integrations/platform_adapters/base.py

@@ -0,0 +1,157 @@
+"""
+Base platform adapter class.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+
+class PlatformAdapter(ABC):
+    """Base class for platform-specific adapters."""
+    
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize platform adapter with configuration."""
+        self.config = config
+        self.platform_name = self.__class__.__name__.replace('Adapter', '').upper()
+    
+    @abstractmethod
+    async def publish_content(
+        self,
+        content: Dict[str, Any],
+        schedule_time: Optional[datetime] = None
+    ) -> Dict[str, Any]:
+        """Publish content to the platform."""
+        pass
+    
+    @abstractmethod
+    async def get_content_status(
+        self,
+        content_id: str
+    ) -> Dict[str, Any]:
+        """Get the status of published content."""
+        pass
+    
+    @abstractmethod
+    async def delete_content(
+        self,
+        content_id: str
+    ) -> Dict[str, Any]:
+        """Delete published content."""
+        pass
+    
+    @abstractmethod
+    async def update_content(
+        self,
+        content_id: str,
+        updates: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Update published content."""
+        pass
+    
+    @abstractmethod
+    async def get_analytics(
+        self,
+        content_id: str,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None
+    ) -> Dict[str, Any]:
+        """Get analytics for published content."""
+        pass
+    
+    @abstractmethod
+    async def validate_content(
+        self,
+        content: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Validate content before publishing."""
+        pass
+    
+    @abstractmethod
+    async def get_optimal_publish_time(
+        self,
+        content_type: str,
+        target_audience: Optional[Dict[str, Any]] = None
+    ) -> datetime:
+        """Get optimal publish time for content."""
+        pass
+    
+    @abstractmethod
+    async def get_platform_limits(
+        self
+    ) -> Dict[str, Any]:
+        """Get platform-specific limits and constraints."""
+        pass
+    
+    @abstractmethod
+    async def get_supported_content_types(
+        self
+    ) -> List[str]:
+        """Get list of supported content types."""
+        pass
+    
+    @abstractmethod
+    async def get_platform_metrics(
+        self
+    ) -> Dict[str, Any]:
+        """Get platform-specific metrics and statistics."""
+        pass
+    
+    def _format_error_response(
+        self,
+        error: Exception,
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Format error response."""
+        return {
+            'success': False,
+            'platform': self.platform_name,
+            'error': str(error),
+            'error_type': error.__class__.__name__,
+            'context': context or {}
+        }
+    
+    def _format_success_response(
+        self,
+        data: Dict[str, Any],
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Format success response."""
+        return {
+            'success': True,
+            'platform': self.platform_name,
+            'data': data,
+            'context': context or {}
+        }
+    
+    def _validate_config(self) -> None:
+        """Validate platform configuration."""
+        required_fields = self.get_required_config_fields()
+        missing_fields = [
+            field for field in required_fields
+            if field not in self.config
+        ]
+        
+        if missing_fields:
+            raise ValueError(
+                f"Missing required configuration fields: {', '.join(missing_fields)}"
+            )
+    
+    @classmethod
+    def get_required_config_fields(cls) -> List[str]:
+        """Get list of required configuration fields."""
+        return []
+    
+    @classmethod
+    def get_platform_name(cls) -> str:
+        """Get platform name."""
+        return cls.__name__.replace('Adapter', '').upper()
+    
+    @classmethod
+    def get_platform_description(cls) -> str:
+        """Get platform description."""
+        return "Base platform adapter"
+    
+    @classmethod
+    def get_platform_version(cls) -> str:
+        """Get platform adapter version."""
+        return "1.0.0"