ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/memory/abstract.py

@@ -0,0 +1,209 @@
+
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+from abc import ABC, abstractmethod
+from datamodel.parsers.json import JSONContent  # pylint: disable=E0611 # noqa
+from navconfig.logging import logging
+
+
+@dataclass
+class ConversationTurn:
+    """Represents a single turn in a conversation."""
+    turn_id: str
+    user_id: str
+    user_message: str
+    assistant_response: str
+    context_used: Optional[str] = None
+    tools_used: List[str] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=datetime.now)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize turn to dictionary."""
+        return {
+            'turn_id': self.turn_id,
+            'user_id': self.user_id,
+            'user_message': self.user_message,
+            'assistant_response': self.assistant_response,
+            'context_used': self.context_used,
+            'tools_used': self.tools_used,
+            'timestamp': self.timestamp.isoformat(),
+            'metadata': self.metadata
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ConversationTurn':
+        """Deserialize turn from dictionary."""
+        return cls(
+            turn_id=data['turn_id'],
+            user_id=data['user_id'],
+            user_message=data['user_message'],
+            assistant_response=data['assistant_response'],
+            context_used=data.get('context_used'),
+            tools_used=data.get('tools_used', []),
+            timestamp=datetime.fromisoformat(data['timestamp']),
+            metadata=data.get('metadata', {})
+        )
+
+
+@dataclass
+class ConversationHistory:
+    """Manages conversation history for a session - replaces ConversationSession."""
+    session_id: str
+    user_id: str
+    chatbot_id: Optional[str] = None
+    turns: List[ConversationTurn] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def add_turn(self, turn: ConversationTurn) -> None:
+        """Add a new turn to the conversation history."""
+        self.turns.append(turn)
+        self.updated_at = datetime.now()
+
+    def get_recent_turns(self, count: int = 5) -> List[ConversationTurn]:
+        """Get the most recent turns for context."""
+        return self.turns[-count:] if count > 0 else self.turns
+
+    def get_messages_for_api(self, model: str = 'claude') -> List[Dict[str, Any]]:
+        """Convert turns to API message format for LLM Model."""
+        messages = []
+        if model == 'claude':
+            # Claude expects messages in a specific format
+            for turn in self.turns:
+                messages.append({
+                    "role": "user",
+                    "content": turn.user_message
+                })
+                messages.append({
+                    "role": "assistant",
+                    "content": turn.assistant_response
+                })
+        else:
+            # Default format for other models
+            # This can be adjusted based on the specific model requirements
+            for turn in self.turns:
+                # Add user message
+                messages.append({
+                    "role": "user",
+                    "content": [{"type": "text", "text": turn.user_message}]
+                })
+                # Add assistant response
+                messages.append({
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": turn.assistant_response}]
+                })
+        return messages
+
+    def clear_turns(self) -> None:
+        """Clear all turns from the conversation history."""
+        self.turns.clear()
+        self.updated_at = datetime.now()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize conversation history to dictionary."""
+        return {
+            'session_id': self.session_id,
+            'user_id': self.user_id,
+            'chatbot_id': self.chatbot_id,
+            'turns': [turn.to_dict() for turn in self.turns],
+            'created_at': self.created_at.isoformat(),
+            'updated_at': self.updated_at.isoformat(),
+            'metadata': self.metadata
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ConversationHistory':
+        """Deserialize conversation history from dictionary."""
+        history = cls(
+            session_id=data['session_id'],
+            user_id=data['user_id'],
+            chatbot_id=data.get('chatbot_id'),
+            created_at=datetime.fromisoformat(data['created_at']),
+            updated_at=datetime.fromisoformat(data['updated_at']),
+            metadata=data.get('metadata', {})
+        )
+
+        for turn_data in data.get('turns', []):
+            turn = ConversationTurn.from_dict(turn_data)
+            history.turns.append(turn)
+
+        return history
+
+class ConversationMemory(ABC):
+    """Abstract base class for conversation memory storage."""
+
+    def __init__(self, debug: bool = False):
+        self.logger = logging.getLogger(
+            f"parrot.Memory.{self.__class__.__name__}"
+        )
+        self._json = JSONContent()
+        self.debug = debug
+
+    @abstractmethod
+    async def create_history(
+        self,
+        user_id: str,
+        session_id: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        chatbot_id: Optional[str] = None
+    ) -> ConversationHistory:
+        """Create a new conversation history."""
+        pass
+
+    @abstractmethod
+    async def get_history(
+        self,
+        user_id: str,
+        session_id: str,
+        chatbot_id: Optional[str] = None
+    ) -> Optional[ConversationHistory]:
+        """Get a conversation history."""
+        pass
+
+    @abstractmethod
+    async def update_history(self, history: ConversationHistory) -> None:
+        """Update a conversation history."""
+        pass
+
+    @abstractmethod
+    async def add_turn(
+        self,
+        user_id: str,
+        session_id: str,
+        turn: ConversationTurn,
+        chatbot_id: Optional[str] = None
+    ) -> None:
+        """Add a turn to the conversation."""
+        pass
+
+    @abstractmethod
+    async def clear_history(
+        self,
+        user_id: str,
+        session_id: str,
+        chatbot_id: Optional[str] = None
+    ) -> None:
+        """Clear a conversation history."""
+        pass
+
+    @abstractmethod
+    async def list_sessions(
+        self,
+        user_id: str,
+        chatbot_id: Optional[str] = None
+    ) -> List[str]:
+        """List all session IDs for a user."""
+        pass
+
+    @abstractmethod
+    async def delete_history(
+        self,
+        user_id: str,
+        session_id: str,
+        chatbot_id: Optional[str] = None
+    ) -> bool:
+        """Delete a conversation history entirely."""
+        pass

parrot/memory/agent.py

@@ -0,0 +1,32 @@
+"""Simple in-memory storage for agent interactions keyed by turn_id."""
+
+import asyncio
+from typing import Any, Dict, Optional
+
+
+class AgentMemory:
+    """Store and retrieve agent interactions by turn identifier."""
+
+    def __init__(self, agent_id: str) -> None:
+        self.agent_id = agent_id
+        self._interactions: Dict[str, Dict[str, Any]] = {self.agent_id: {}}
+        self._lock = asyncio.Lock()
+
+    async def store_interaction(self, turn_id: str, question: str, answer: Any) -> None:
+        """Persist a question/answer pair under the provided turn identifier."""
+        if not turn_id:
+            raise ValueError("turn_id is required to store an interaction")
+
+        async with self._lock:
+            self._interactions[self.agent_id][turn_id] = {
+                "question": question,
+                "answer": answer,
+            }
+
+    async def get(self, turn_id: str) -> Optional[Dict[str, Any]]:
+        """Retrieve a stored interaction by turn identifier."""
+        if not turn_id:
+            return None
+
+        async with self._lock:
+            return self._interactions.get(self.agent_id, {}).get(turn_id)

parrot/memory/cache.py

@@ -0,0 +1,175 @@
+from typing import Any, Optional, Callable, TypeVar, ParamSpec
+from functools import wraps
+from abc import ABC
+import asyncio
+import hashlib
+import inspect
+import redis.asyncio as aioredis
+from datamodel.parsers.json import json_encoder, json_decoder  # pylint: disable=E0611 # noqa
+from ..conf import REDIS_URL
+
+
+P = ParamSpec('P')
+T = TypeVar('T')
+
+
+class CacheMixin(ABC):
+    """Mixin to add caching capabilities using Redis."""
+
+    def __init__(self, redis_url: str = None, **kwargs):
+        # Redis connection for caching
+        self.redis = aioredis.from_url(
+            redis_url or REDIS_URL,
+            encoding="utf-8",
+            decode_responses=True
+        )
+        self.default_ttl = kwargs.get('default_ttl', 3600)
+        self.key_prefix = "hierarchy:"
+
+    def _generate_cache_key(self, query_type: str, **params) -> str:
+        """
+        Generate a unique cache key based on the query type and parameters.
+        """
+        # Ordenar params para consistencia
+        sorted_params = json_encoder(params)
+        param_hash = hashlib.md5(sorted_params.encode()).hexdigest()
+        return f"{self.key_prefix}{query_type}:{param_hash}"
+
+    async def get(self, query_type: str, **params) -> Optional[Any]:
+        """
+        Get a cached value from Redis based on the query type and parameters.
+        """
+        key = self._generate_cache_key(query_type, **params)
+
+        try:
+            return json_decoder(cached) if (cached := await self.redis.get(key)) else None
+        except Exception as e:
+            print(f"Cache error (get): {e}")
+            return None
+
+    async def set(
+        self,
+        query_type: str,
+        value: Any,
+        ttl: Optional[int] = None,
+        **params
+    ):
+        """
+        Save result to cache with TTL (async).
+        """
+        key = self._generate_cache_key(query_type, **params)
+        ttl = ttl or self.default_ttl
+
+        try:
+            await self.redis.setex(
+                key,
+                ttl,
+                json_encoder(value)
+            )
+        except Exception as e:
+            print(f"Cache error (set): {e}")
+
+    async def invalidate_cache(self, object_oid: str):
+        """
+        Invalidate cache related to an object (async).
+        """
+        pattern = f"{self.key_prefix}*{object_oid}*"
+
+        try:
+            # Use scan_iter to avoid blocking
+            keys = []
+            async for key in self.redis.scan_iter(match=pattern):
+                keys.append(key)
+
+            if keys:
+                await self.redis.delete(*keys)
+                print(
+                    f"Invalidated {len(keys)} keys for {object_oid}"
+                )
+        except Exception as e:
+            print(f"Cache error (invalidate): {e}")
+
+    async def clear_all(self):
+        """Clear all hierarchy cache (async)."""
+        pattern = f"{self.key_prefix}*"
+
+        try:
+            keys = []
+            async for key in self.redis.scan_iter(match=pattern):
+                keys.append(key)
+
+            if keys:
+                await self.redis.delete(*keys)
+                print(f"Cleared {len(keys)} cache keys")
+        except Exception as e:
+            print(f"Cache error (clear): {e}")
+
+
+def cached_query(
+    query_type: str,
+    ttl: Optional[int] = None
+) -> Callable[[Callable[P, asyncio.Future[T]]], Callable[P, asyncio.Future[T]]]:
+    """
+    Decorator to cache the result of async methods in classes
+    that inherit from CacheMixin.
+
+    Usage:
+    ```python
+    @cached_query("get_superiors", ttl=600)
+    def get_all_superiors(self, employee_oid: str):
+        ...
+    ```
+    """
+
+    def decorator(
+        func: Callable[P, asyncio.Future[T]]
+    ) -> Callable[P, asyncio.Future[T]]:
+        @wraps(func)
+        async def wrapper(
+            self: CacheMixin,
+            *args: P.args,
+            **kwargs: P.kwargs
+        ) -> T:
+
+            # Build cache parameters
+            sig = inspect.signature(func)
+            param_names = list(sig.parameters.keys())[1:]  # Skip 'self'
+
+            cache_params = kwargs.copy()
+            for i, arg in enumerate(args):
+                if i < len(param_names):
+                    cache_params[param_names[i]] = arg  # ✅ Mapping arg → param name
+
+            # Attempt to get from cache
+            cached_result = await self.get(
+                query_type,
+                **cache_params
+            )
+            if cached_result is not None:
+                return cached_result
+
+            # Call the original function
+            if asyncio.iscoroutinefunction(func):
+                result = await func(self, *args, **kwargs)
+            else:
+                # executing sync method in thread pool
+                loop = asyncio.get_running_loop()
+                result = await loop.run_in_executor(
+                    None, lambda: func(self, *args, **kwargs)
+                )
+
+            # Save to cache, fire and forget:
+            asyncio.create_task(
+                self.set(
+                    query_type,
+                    result,
+                    ttl,
+                    **cache_params
+                )
+            )
+
+            return result
+
+        return wrapper
+
+    return decorator