ainative-python 2.0.0__py3-none-any.whl

ainative/zerodb/analytics.py

@@ -0,0 +1,232 @@
+"""
+ZeroDB Analytics Module
+
+Provides analytics and insights for ZeroDB operations.
+"""
+
+from typing import TYPE_CHECKING, Dict, Any, Optional, List
+from datetime import datetime, timedelta
+
+if TYPE_CHECKING:
+    from ..client import AINativeClient
+
+
+class AnalyticsClient:
+    """Client for ZeroDB analytics operations."""
+    
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize analytics client.
+        
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/zerodb/analytics"
+    
+    def get_usage(
+        self,
+        project_id: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        granularity: str = "daily",
+    ) -> Dict[str, Any]:
+        """
+        Get usage analytics.
+        
+        Args:
+            project_id: Optional project ID filter
+            start_date: Start date for analytics
+            end_date: End date for analytics
+            granularity: Data granularity (hourly, daily, weekly, monthly)
+        
+        Returns:
+            Usage analytics data
+        """
+        params = {"granularity": granularity}
+        
+        if project_id:
+            params["project_id"] = project_id
+        if start_date:
+            params["start_date"] = start_date.isoformat()
+        if end_date:
+            params["end_date"] = end_date.isoformat()
+        
+        return self.client.get(f"{self.base_path}/usage", params=params)
+    
+    def get_performance_metrics(
+        self,
+        project_id: Optional[str] = None,
+        metric_type: str = "all",
+    ) -> Dict[str, Any]:
+        """
+        Get performance metrics.
+        
+        Args:
+            project_id: Optional project ID filter
+            metric_type: Type of metrics (latency, throughput, errors, all)
+        
+        Returns:
+            Performance metrics data
+        """
+        params = {"metric_type": metric_type}
+        
+        if project_id:
+            params["project_id"] = project_id
+        
+        return self.client.get(f"{self.base_path}/performance", params=params)
+    
+    def get_storage_stats(
+        self,
+        project_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get storage statistics.
+        
+        Args:
+            project_id: Optional project ID filter
+        
+        Returns:
+            Storage statistics including size, vector count, etc.
+        """
+        params = {}
+        if project_id:
+            params["project_id"] = project_id
+        
+        return self.client.get(f"{self.base_path}/storage", params=params)
+    
+    def get_query_insights(
+        self,
+        project_id: Optional[str] = None,
+        limit: int = 100,
+    ) -> Dict[str, Any]:
+        """
+        Get query pattern insights.
+        
+        Args:
+            project_id: Optional project ID filter
+            limit: Maximum number of insights
+        
+        Returns:
+            Query insights and patterns
+        """
+        params = {"limit": limit}
+        
+        if project_id:
+            params["project_id"] = project_id
+        
+        return self.client.get(f"{self.base_path}/queries", params=params)
+    
+    def get_cost_analysis(
+        self,
+        project_id: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get cost analysis and projections.
+        
+        Args:
+            project_id: Optional project ID filter
+            start_date: Start date for analysis
+            end_date: End date for analysis
+        
+        Returns:
+            Cost analysis data
+        """
+        params = {}
+        
+        if project_id:
+            params["project_id"] = project_id
+        if start_date:
+            params["start_date"] = start_date.isoformat()
+        if end_date:
+            params["end_date"] = end_date.isoformat()
+        
+        return self.client.get(f"{self.base_path}/costs", params=params)
+    
+    def get_trends(
+        self,
+        metric: str,
+        project_id: Optional[str] = None,
+        period: int = 30,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get trend data for specific metrics.
+        
+        Args:
+            metric: Metric name (vectors, queries, storage, errors)
+            project_id: Optional project ID filter
+            period: Number of days to analyze
+        
+        Returns:
+            Trend data points
+        """
+        params = {
+            "metric": metric,
+            "period": period,
+        }
+        
+        if project_id:
+            params["project_id"] = project_id
+        
+        response = self.client.get(f"{self.base_path}/trends", params=params)
+        return response.get("data", [])
+    
+    def get_anomalies(
+        self,
+        project_id: Optional[str] = None,
+        severity: str = "all",
+    ) -> List[Dict[str, Any]]:
+        """
+        Get detected anomalies in usage patterns.
+        
+        Args:
+            project_id: Optional project ID filter
+            severity: Severity filter (low, medium, high, critical, all)
+        
+        Returns:
+            List of detected anomalies
+        """
+        params = {"severity": severity}
+        
+        if project_id:
+            params["project_id"] = project_id
+        
+        response = self.client.get(f"{self.base_path}/anomalies", params=params)
+        return response.get("anomalies", [])
+    
+    def export_report(
+        self,
+        report_type: str = "summary",
+        project_id: Optional[str] = None,
+        format: str = "json",
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+    ) -> Dict[str, Any]:
+        """
+        Export analytics report.
+        
+        Args:
+            report_type: Type of report (summary, detailed, custom)
+            project_id: Optional project ID filter
+            format: Export format (json, csv, pdf)
+            start_date: Start date for report
+            end_date: End date for report
+        
+        Returns:
+            Report data or download URL
+        """
+        data = {
+            "report_type": report_type,
+            "format": format,
+        }
+        
+        if project_id:
+            data["project_id"] = project_id
+        if start_date:
+            data["start_date"] = start_date.isoformat()
+        if end_date:
+            data["end_date"] = end_date.isoformat()
+        
+        return self.client.post(f"{self.base_path}/export", data=data)

ainative/zerodb/memory.py

@@ -0,0 +1,260 @@
+"""
+ZeroDB Memory Module
+
+Handles memory operations for context retention and retrieval.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+from datetime import datetime
+from enum import Enum
+
+if TYPE_CHECKING:
+    from ..client import AINativeClient
+
+
+class MemoryPriority(Enum):
+    """Memory priority levels."""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class MemoryClient:
+    """Client for ZeroDB memory operations."""
+    
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize memory client.
+        
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/zerodb/memory"
+    
+    def create(
+        self,
+        content: str,
+        title: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        priority: MemoryPriority = MemoryPriority.MEDIUM,
+        metadata: Optional[Dict[str, Any]] = None,
+        project_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        expires_at: Optional[datetime] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new memory entry.
+        
+        Args:
+            content: Memory content
+            title: Memory title
+            tags: List of tags
+            priority: Memory priority level
+            metadata: Additional metadata
+            project_id: Associated project ID
+            user_id: Associated user ID
+            expires_at: Expiration timestamp
+        
+        Returns:
+            Created memory details
+        """
+        data = {
+            "content": content,
+            "title": title or "Memory Entry",
+            "tags": tags or [],
+            "priority": priority.value,
+            "metadata": metadata or {},
+        }
+        
+        if project_id:
+            data["project_id"] = project_id
+        if user_id:
+            data["user_id"] = user_id
+        if expires_at:
+            data["expires_at"] = expires_at.isoformat()
+        
+        return self.client.post(self.base_path, data=data)
+    
+    def list(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        project_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        priority: Optional[MemoryPriority] = None,
+        search: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        List memory entries.
+        
+        Args:
+            limit: Maximum number of entries to return
+            offset: Number of entries to skip
+            project_id: Filter by project ID
+            user_id: Filter by user ID
+            tags: Filter by tags
+            priority: Filter by priority
+            search: Search query
+        
+        Returns:
+            Dictionary containing memories list and pagination info
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+        }
+        
+        if project_id:
+            params["project_id"] = project_id
+        if user_id:
+            params["user_id"] = user_id
+        if tags:
+            params["tags"] = ",".join(tags)
+        if priority:
+            params["priority"] = priority.value
+        if search:
+            params["search"] = search
+        
+        return self.client.get(f"{self.base_path}ies", params=params)
+    
+    def get(self, memory_id: str) -> Dict[str, Any]:
+        """
+        Get a specific memory entry.
+        
+        Args:
+            memory_id: Memory ID
+        
+        Returns:
+            Memory details
+        """
+        return self.client.get(f"{self.base_path}/{memory_id}")
+    
+    def update(
+        self,
+        memory_id: str,
+        content: Optional[str] = None,
+        title: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        priority: Optional[MemoryPriority] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update a memory entry.
+        
+        Args:
+            memory_id: Memory ID
+            content: New content
+            title: New title
+            tags: New tags
+            priority: New priority
+            metadata: New metadata
+        
+        Returns:
+            Updated memory details
+        """
+        data = {}
+        if content is not None:
+            data["content"] = content
+        if title is not None:
+            data["title"] = title
+        if tags is not None:
+            data["tags"] = tags
+        if priority is not None:
+            data["priority"] = priority.value
+        if metadata is not None:
+            data["metadata"] = metadata
+        
+        return self.client.patch(f"{self.base_path}/{memory_id}", data=data)
+    
+    def delete(self, memory_id: str) -> Dict[str, Any]:
+        """
+        Delete a memory entry.
+        
+        Args:
+            memory_id: Memory ID
+        
+        Returns:
+            Deletion confirmation
+        """
+        return self.client.delete(f"{self.base_path}/{memory_id}")
+    
+    def search(
+        self,
+        query: str,
+        limit: int = 10,
+        project_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        semantic: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search memories using text or semantic search.
+        
+        Args:
+            query: Search query
+            limit: Maximum number of results
+            project_id: Filter by project ID
+            user_id: Filter by user ID
+            semantic: Use semantic search (if False, uses text search)
+        
+        Returns:
+            List of matching memories
+        """
+        data = {
+            "query": query,
+            "limit": limit,
+            "semantic": semantic,
+        }
+        
+        if project_id:
+            data["project_id"] = project_id
+        if user_id:
+            data["user_id"] = user_id
+        
+        response = self.client.post(f"{self.base_path}/search", data=data)
+        return response.get("results", [])
+    
+    def bulk_create(
+        self,
+        memories: List[Dict[str, Any]],
+        project_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create multiple memory entries at once.
+        
+        Args:
+            memories: List of memory data dictionaries
+            project_id: Project ID for all memories
+        
+        Returns:
+            Bulk creation result
+        """
+        data = {
+            "memories": memories,
+        }
+        
+        if project_id:
+            data["project_id"] = project_id
+        
+        return self.client.post(f"{self.base_path}/bulk", data=data)
+    
+    def get_related(
+        self,
+        memory_id: str,
+        limit: int = 5,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get memories related to a specific memory.
+        
+        Args:
+            memory_id: Memory ID
+            limit: Maximum number of related memories
+        
+        Returns:
+            List of related memories
+        """
+        params = {"limit": limit}
+        response = self.client.get(f"{self.base_path}/{memory_id}/related", params=params)
+        return response.get("memories", [])

ainative/zerodb/projects.py

@@ -0,0 +1,224 @@
+"""
+ZeroDB Projects Module
+
+Handles project management operations in ZeroDB.
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional
+from datetime import datetime
+from enum import Enum
+
+if TYPE_CHECKING:
+    from ..client import AINativeClient
+
+
+class ProjectStatus(Enum):
+    """Project status enumeration."""
+    ACTIVE = "active"
+    SUSPENDED = "suspended"
+    ARCHIVED = "archived"
+    DELETED = "deleted"
+
+
+class ProjectsClient:
+    """Client for ZeroDB project operations."""
+    
+    def __init__(self, client: "AINativeClient"):
+        """
+        Initialize projects client.
+        
+        Args:
+            client: Parent AINative client instance
+        """
+        self.client = client
+        self.base_path = "/zerodb/projects"
+    
+    def list(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        status: Optional[ProjectStatus] = None,
+        organization_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        List all projects.
+        
+        Args:
+            limit: Maximum number of projects to return
+            offset: Number of projects to skip
+            status: Filter by project status
+            organization_id: Filter by organization ID
+        
+        Returns:
+            Dictionary containing projects list and pagination info
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+        }
+        
+        if status:
+            params["status"] = status.value
+        if organization_id:
+            params["organization_id"] = organization_id
+        
+        return self.client.get(self.base_path, params=params)
+    
+    def create(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new project.
+        
+        Args:
+            name: Project name
+            description: Project description
+            metadata: Additional metadata
+            config: Project configuration
+        
+        Returns:
+            Created project details
+        """
+        data = {
+            "name": name,
+            "description": description or "",
+            "metadata": metadata or {},
+            "config": config or {},
+        }
+        
+        return self.client.post(self.base_path, data=data)
+    
+    def get(self, project_id: str) -> Dict[str, Any]:
+        """
+        Get project details.
+        
+        Args:
+            project_id: Project ID
+        
+        Returns:
+            Project details
+        """
+        return self.client.get(f"{self.base_path}/{project_id}")
+    
+    def update(
+        self,
+        project_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update project details.
+        
+        Args:
+            project_id: Project ID
+            name: New project name
+            description: New project description
+            metadata: Updated metadata
+            config: Updated configuration
+        
+        Returns:
+            Updated project details
+        """
+        data = {}
+        if name is not None:
+            data["name"] = name
+        if description is not None:
+            data["description"] = description
+        if metadata is not None:
+            data["metadata"] = metadata
+        if config is not None:
+            data["config"] = config
+        
+        return self.client.patch(f"{self.base_path}/{project_id}", data=data)
+    
+    def update_status(
+        self,
+        project_id: str,
+        status: ProjectStatus,
+        reason: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update project status.
+        
+        Args:
+            project_id: Project ID
+            status: New status
+            reason: Reason for status change
+        
+        Returns:
+            Updated project details
+        """
+        data = {
+            "status": status.value,
+            "reason": reason,
+        }
+        
+        return self.client.put(f"{self.base_path}/{project_id}/status", data=data)
+    
+    def suspend(self, project_id: str, reason: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Suspend a project.
+        
+        Args:
+            project_id: Project ID
+            reason: Reason for suspension
+        
+        Returns:
+            Updated project details
+        """
+        return self.update_status(project_id, ProjectStatus.SUSPENDED, reason)
+    
+    def activate(self, project_id: str) -> Dict[str, Any]:
+        """
+        Activate a suspended project.
+        
+        Args:
+            project_id: Project ID
+        
+        Returns:
+            Updated project details
+        """
+        return self.update_status(project_id, ProjectStatus.ACTIVE)
+    
+    def delete(self, project_id: str) -> Dict[str, Any]:
+        """
+        Delete a project.
+        
+        Args:
+            project_id: Project ID
+        
+        Returns:
+            Deletion confirmation
+        """
+        return self.client.delete(f"{self.base_path}/{project_id}")
+    
+    def get_statistics(self, project_id: str) -> Dict[str, Any]:
+        """
+        Get project statistics.
+        
+        Args:
+            project_id: Project ID
+        
+        Returns:
+            Project statistics including storage, vectors, etc.
+        """
+        return self.client.get(f"{self.base_path}/{project_id}/statistics")
+    
+    def get_collections(self, project_id: str) -> List[Dict[str, Any]]:
+        """
+        Get all collections for a project.
+        
+        Args:
+            project_id: Project ID
+        
+        Returns:
+            List of collections
+        """
+        response = self.client.get(f"{self.base_path}/{project_id}/collections")
+        return response.get("collections", [])