chuk-ai-session-manager 0.1.1__py3-none-any.whl → 0.2__py3-none-any.whl

{chuk_ai_session_manager-0.1.1.dist-info → chuk_ai_session_manager-0.2.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: chuk-ai-session-manager
-Version: 0.1.1
+Version: 0.2
 Summary: Session manager for AI applications
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: chuk-sessions>=0.3
 Requires-Dist: chuk-tool-processor>=0.4.1
 Requires-Dist: pydantic>=2.11.3
 Provides-Extra: tiktoken
@@ -70,10 +71,10 @@ This isn't just a demo framework - it's designed for production AI applications
 
 ```python
 import asyncio
-from chuk_ai_session_manager.models.session import Session
+from chuk_ai_session_manager.session import Session
 from chuk_ai_session_manager.models.session_event import SessionEvent
 from chuk_ai_session_manager.models.event_source import EventSource
-from chuk_ai_session_manager.storage import SessionStoreProvider, InMemorySessionStore
+from chuk_ai_session_manager.chuk_sessions_storage import get_backend, ChukSessionsStore, InMemorySessionStore
 
 async def main():
     # Set up storage
@@ -116,8 +117,8 @@ import asyncio
 import json
 from openai import AsyncOpenAI
 from chuk_tool_processor.registry import initialize
-from chuk_ai_session_manager.models.session import Session
-from chuk_ai_session_manager.storage import SessionStoreProvider, InMemorySessionStore
+from chuk_ai_session_manager.session import Session
+from chuk_ai_session_manager.chuk_sessions_storage import get_backend, ChukSessionsStore, InMemorySessionStore
 
 # Import tools - auto-registers via decorators
 from your_tools import sample_tools
@@ -160,7 +161,7 @@ asyncio.run(openai_integration_demo())
 
 ### In-Memory (Default)
 ```python
-from chuk_ai_session_manager.storage import InMemorySessionStore, SessionStoreProvider
+from chuk_ai_session_manager.chuk_sessions_storage import InMemorySessionStore, SessionStoreProvider
 
 # Great for testing or single-process applications
 store = InMemorySessionStore()
@@ -169,7 +170,7 @@ SessionStoreProvider.set_store(store)
 
 ### File Storage
 ```python
-from chuk_ai_session_manager.storage.providers.file import create_file_session_store
+from chuk_ai_session_manager.chuk_sessions_storage.providers.file import create_file_session_store
 
 # Persistent JSON file storage with async I/O
 store = await create_file_session_store(directory="./sessions")
@@ -178,7 +179,7 @@ SessionStoreProvider.set_store(store)
 
 ### Redis Storage
 ```python
-from chuk_ai_session_manager.storage.providers.redis import create_redis_session_store
+from chuk_ai_session_manager.chuk_sessions_storage.providers.redis import create_redis_session_store
 
 # Distributed storage for production with TTL
 store = await create_redis_session_store(

chuk_ai_session_manager-0.2.dist-info/RECORD

@@ -0,0 +1,23 @@
+chuk_ai_session_manager/__init__.py,sha256=0a8NezasrQJe2jm-1pZpzqPI-JCnrPNGTRLKDPRtyuk,11009
+chuk_ai_session_manager/exceptions.py,sha256=WqrrUZuOAiUmz7tKnSnk0y222U_nV9a8LyaXLayn2fg,4420
+chuk_ai_session_manager/infinite_conversation.py,sha256=7j3caMnsX27M5rjj4oOkqiy_2AfcupWwsAWRflnKiSo,12092
+chuk_ai_session_manager/sample_tools.py,sha256=yZDM-ast5lv0YVHcd3GTxBMcJd7zuNkUhZPVIb06G0c,8155
+chuk_ai_session_manager/session_aware_tool_processor.py,sha256=iVe3d-qfp5QGkdNrgfZeRYoOjd8nLZ0g6K7HW1thFE8,7274
+chuk_ai_session_manager/session_prompt_builder.py,sha256=-ZTUczYh5emToInp4TRCj9FvF4CECyn45YHYKoWzmxE,17328
+chuk_ai_session_manager/session_storage.py,sha256=HqzYDtwx4zN5an1zJmSZc56BpyD3KjT3IWonIpmnVXQ,5790
+chuk_ai_session_manager/api/__init__.py,sha256=Lo_BoDW2rSn0Zw-CbjahOxc6ykjjTpucxHZo5FA2Gnc,41
+chuk_ai_session_manager/api/simple_api.py,sha256=N2Y0b7JkQsWLCvU1uGyAfYTGqyyCmG26X2PnKt3vux4,12040
+chuk_ai_session_manager/models/__init__.py,sha256=H1rRuDQDRf821JPUWUn5Zgwvc5BAqcEGekkHEmX-IgE,1167
+chuk_ai_session_manager/models/event_source.py,sha256=mn_D16sXMa6nAX-5BzssygJPz6VF24GRe-3IaH7bTnI,196
+chuk_ai_session_manager/models/event_type.py,sha256=TPPvAz-PlXVtrwXDNVFVnhdt1yEfgDGmKDGt8ArYcTk,275
+chuk_ai_session_manager/models/session.py,sha256=Txnmqd5SmiMz6acur_zL5MiFHJjKqU2se895p7_zUNQ,11781
+chuk_ai_session_manager/models/session_event.py,sha256=YPDbymduF42LLHtAv_k_kqlWF68vnth5J_HM4q-bOyI,5896
+chuk_ai_session_manager/models/session_metadata.py,sha256=KFG7lc_E0BQTP2OD9Y529elVGJXppDUMqz8vVONW0rw,1510
+chuk_ai_session_manager/models/session_run.py,sha256=uhMM4-WSrqOUsiWQPnyakInd-foZhxI-YnSHSWiZZwE,4369
+chuk_ai_session_manager/models/token_usage.py,sha256=pnsNDMew9ToUqkRCIz1TADnHC5aKnautdLD4trCA6Zg,11121
+chuk_ai_session_manager/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chuk_ai_session_manager/utils/status_display_utils.py,sha256=id4TIE0VSq3thvDd4wKIyk3kBr_bUMqrtXmOI9CD8r8,19231
+chuk_ai_session_manager-0.2.dist-info/METADATA,sha256=jucZml2QT7GsqdM8I4U5I7uBm8pdWtrS2dNdvWYoxvc,16465
+chuk_ai_session_manager-0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_ai_session_manager-0.2.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
+chuk_ai_session_manager-0.2.dist-info/RECORD,,

chuk_ai_session_manager/storage/__init__.py

@@ -1,44 +0,0 @@
-# chuk_ai_session_manager/storage/__init__.py
-"""
-Storage module for the chuk session manager.
-"""
-# Import base components first to avoid circular imports
-try:
-    from chuk_ai_session_manager.storage.base import SessionStoreInterface, SessionStoreProvider
-except ImportError:
-    pass
-
-# Try to import providers if available
-try:
-    from chuk_ai_session_manager.storage.providers.memory import InMemorySessionStore
-except ImportError:
-    pass
-
-try:
-    from chuk_ai_session_manager.storage.providers.file import FileSessionStore, create_file_session_store
-except ImportError:
-    pass
-
-# Try to import Redis - this is optional
-try:
-    from chuk_ai_session_manager.storage.providers.redis import RedisSessionStore, create_redis_session_store
-    _has_redis = True
-except ImportError:
-    _has_redis = False
-
-# Define __all__ based on what was successfully imported
-__all__ = []
-
-# Basic components
-for name in ['SessionStoreInterface', 'SessionStoreProvider', 'InMemorySessionStore']:
-    if name in globals():
-        __all__.append(name)
-
-# File store
-for name in ['FileSessionStore', 'create_file_session_store']:
-    if name in globals():
-        __all__.append(name)
-
-# Redis store (optional)
-if _has_redis:
-    __all__.extend(['RedisSessionStore', 'create_redis_session_store'])

chuk_ai_session_manager/storage/base.py

@@ -1,50 +0,0 @@
-# chuk_ai_session_manager/storage/base.py
-"""
-Base interfaces and providers for async session storage.
-"""
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, TypeVar
-
-T = TypeVar('T')
-
-class SessionStoreInterface(ABC):
-    """Interface for pluggable async session stores."""
-    
-    @abstractmethod
-    async def get(self, session_id: str) -> Optional[Any]:
-        """Retrieve a session by its ID, or None if not found."""
-        ...
-
-    @abstractmethod
-    async def save(self, session: Any) -> None:
-        """Save or update a session object in the store."""
-        ...
-    
-    @abstractmethod
-    async def delete(self, session_id: str) -> None:
-        """Delete a session by its ID."""
-        ...
-    
-    @abstractmethod
-    async def list_sessions(self, prefix: str = "") -> List[str]:
-        """List all session IDs, optionally filtered by prefix."""
-        ...
-
-
-class SessionStoreProvider:
-    """Provider for a globally-shared async session store."""
-    _store: Optional[SessionStoreInterface] = None
-
-    @classmethod
-    def get_store(cls) -> SessionStoreInterface:
-        """Get the currently configured session store."""
-        if cls._store is None:
-            # Defer import to avoid circular imports
-            from chuk_ai_session_manager.storage.providers.memory import InMemorySessionStore
-            cls._store = InMemorySessionStore()
-        return cls._store
-
-    @classmethod
-    def set_store(cls, store: SessionStoreInterface) -> None:
-        """Set a new session store implementation."""
-        cls._store = store

chuk_ai_session_manager/storage/providers/file.py

@@ -1,348 +0,0 @@
-# chuk_ai_session_manager/storage/providers/file.py
-
-"""
-Async file-based session storage implementation with improved async semantics.
-"""
-import json
-import logging
-import asyncio
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Type, TypeVar, Union, Generic
-import os
-
-# Check for aiofiles availability
-try:
-    import aiofiles
-    AIOFILES_AVAILABLE = True
-except ImportError:
-    AIOFILES_AVAILABLE = False
-    logging.warning("aiofiles package not installed; falling back to synchronous I/O in thread pool.")
-
-# session manager imports
-from chuk_ai_session_manager.models.session import Session
-from chuk_ai_session_manager.storage.base import SessionStoreInterface
-from chuk_ai_session_manager.exceptions import SessionManagerError
-
-# Type variable for serializable models
-T = TypeVar('T', bound='Session')
-
-# Setup logging
-logger = logging.getLogger(__name__)
-
-
-class FileStorageError(SessionManagerError):
-    """Raised when file storage operations fail."""
-    pass
-
-
-class SessionSerializer(Generic[T]):
-    """Handles serialization and deserialization of session objects."""
-
-    @classmethod
-    def to_dict(cls, obj: T) -> Dict[str, Any]:
-        """Convert a session object to a dictionary for serialization."""
-        # Use Pydantic's model_dump method for serialization
-        return obj.model_dump()
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any], model_class: Type[T]) -> T:
-        """Convert a dictionary to a session object."""
-        try:
-            # Use Pydantic's model validation for deserialization
-            return model_class.model_validate(data)
-        except Exception as e:
-            raise FileStorageError(f"Failed to deserialize {model_class.__name__}: {str(e)}")
-
-
-class FileSessionStore(SessionStoreInterface, Generic[T]):
-    """
-    An async file session store that persists sessions to JSON files.
-    
-    This implementation stores each session as a separate JSON file in
-    the specified directory, using aiofiles for non-blocking I/O when available.
-    It uses file locks to prevent race conditions during reads and writes.
-    """
-    
-    def __init__(self, 
-                directory: Union[str, Path], 
-                session_class: Type[T] = Session,
-                auto_save: bool = True):
-        """
-        Initialize the async file session store.
-        
-        Args:
-            directory: Directory where session files will be stored
-            session_class: The Session class to use for deserialization
-            auto_save: Whether to automatically save on each update
-        """
-        self.directory = Path(directory)
-        self.directory.mkdir(parents=True, exist_ok=True)
-        self.session_class = session_class
-        self.auto_save = auto_save
-        
-        # In-memory cache for better performance
-        self._cache: Dict[str, T] = {}
-        
-        # Locks for file operations (keyed by session ID)
-        self._locks: Dict[str, asyncio.Lock] = {}
-    
-    def _get_path(self, session_id: str) -> Path:
-        """Get the file path for a session ID."""
-        return self.directory / f"{session_id}.json"
-    
-    def _json_default(self, obj: Any) -> Any:
-        """Handle non-serializable objects in JSON serialization."""
-        if isinstance(obj, datetime):
-            return obj.isoformat()
-        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
-    
-    async def _get_lock(self, session_id: str) -> asyncio.Lock:
-        """Get a lock for a specific session ID."""
-        if session_id not in self._locks:
-            self._locks[session_id] = asyncio.Lock()
-        return self._locks[session_id]
-
-    async def get(self, session_id: str) -> Optional[T]:
-        """Async: Retrieve a session by its ID."""
-        # Check cache first
-        if session_id in self._cache:
-            return self._cache[session_id]
-        
-        # If not in cache, try to load from file
-        file_path = self._get_path(session_id)
-        if not file_path.exists():
-            return None
-        
-        # Get lock for this session
-        lock = await self._get_lock(session_id)
-        
-        # Use lock for file read to prevent race conditions
-        async with lock:
-            try:
-                if AIOFILES_AVAILABLE:
-                    async with aiofiles.open(file_path, 'r', encoding='utf-8') as f:
-                        data_str = await f.read()
-                        data = json.loads(data_str)
-                else:
-                    # If aiofiles not available, use executor to avoid blocking
-                    loop = asyncio.get_running_loop()
-                    data_str = await loop.run_in_executor(
-                        None,
-                        lambda: open(file_path, 'r', encoding='utf-8').read()
-                    )
-                    data = json.loads(data_str)
-                
-                session = SessionSerializer.from_dict(data, self.session_class)
-                # Update cache
-                self._cache[session_id] = session
-                return session
-            except (FileStorageError, json.JSONDecodeError, IOError) as e:
-                logger.error(f"Failed to load session {session_id}: {e}")
-                return None
-
-    async def save(self, session: T) -> None:
-        """Async: Save a session to the store."""
-        session_id = session.id
-        # Update cache
-        self._cache[session_id] = session
-        
-        if self.auto_save:
-            await self._save_to_file(session)
-    
-    async def _save_to_file(self, session: T) -> None:
-        """Async: Save a session to its JSON file."""
-        session_id = session.id
-        file_path = self._get_path(session_id)
-        
-        # Get lock for this session
-        lock = await self._get_lock(session_id)
-        
-        # Use lock for file write to prevent race conditions
-        async with lock:
-            try:
-                # Create temp file first to avoid partial writes
-                temp_path = file_path.with_suffix('.tmp')
-                
-                data = SessionSerializer.to_dict(session)
-                json_str = json.dumps(data, default=self._json_default, indent=2)
-                
-                if AIOFILES_AVAILABLE:
-                    async with aiofiles.open(temp_path, 'w', encoding='utf-8') as f:
-                        await f.write(json_str)
-                else:
-                    # If aiofiles not available, use executor to avoid blocking
-                    loop = asyncio.get_running_loop()
-                    await loop.run_in_executor(
-                        None,
-                        lambda: open(temp_path, 'w', encoding='utf-8').write(json_str)
-                    )
-                
-                # Rename temp file to actual file (atomic operation)
-                os.replace(temp_path, file_path)
-                
-            except (FileStorageError, IOError, TypeError) as e:
-                logger.error(f"Failed to save session {session_id}: {e}")
-                if temp_path.exists():
-                    temp_path.unlink()  # Clean up temp file
-                raise FileStorageError(f"Failed to save session {session_id}: {str(e)}")
-
-    async def delete(self, session_id: str) -> None:
-        """Async: Delete a session by its ID."""
-        # Remove from cache
-        if session_id in self._cache:
-            del self._cache[session_id]
-        
-        # Get lock for this session
-        lock = await self._get_lock(session_id)
-        
-        # Use lock for deletion to prevent race conditions
-        async with lock:
-            # Remove file if it exists
-            file_path = self._get_path(session_id)
-            if file_path.exists():
-                try:
-                    # Run in executor to avoid blocking
-                    loop = asyncio.get_running_loop()
-                    await loop.run_in_executor(None, file_path.unlink)
-                except IOError as e:
-                    logger.error(f"Failed to delete session file {session_id}: {e}")
-                    raise FileStorageError(f"Failed to delete session {session_id}: {str(e)}")
-            
-            # Remove lock for this session
-            if session_id in self._locks:
-                del self._locks[session_id]
-    
-    async def list_sessions(self, prefix: str = "") -> List[str]:
-        """Async: List all session IDs, optionally filtered by prefix."""
-        try:
-            # Run in executor to avoid blocking
-            loop = asyncio.get_running_loop()
-            files = await loop.run_in_executor(
-                None,
-                lambda: list(self.directory.glob("*.json"))
-            )
-            
-            # Extract the session IDs (filenames without extension)
-            session_ids = [f.stem for f in files]
-            
-            # Filter by prefix if provided
-            if prefix:
-                session_ids = [sid for sid in session_ids if sid.startswith(prefix)]
-                
-            return session_ids
-        except IOError as e:
-            logger.error(f"Failed to list sessions: {e}")
-            raise FileStorageError(f"Failed to list sessions: {str(e)}")
-    
-    async def flush(self) -> None:
-        """Async: Force save all cached sessions to disk."""
-        save_tasks = []
-        for session in self._cache.values():
-            # Create tasks but don't await them yet
-            task = asyncio.create_task(self._save_to_file(session))
-            save_tasks.append(task)
-            
-        # Wait for all save operations to complete
-        if save_tasks:
-            # Use gather with return_exceptions to prevent one error from stopping all saves
-            results = await asyncio.gather(*save_tasks, return_exceptions=True)
-            
-            # Log any errors
-            for result in results:
-                if isinstance(result, Exception):
-                    logger.error(f"Error during flush: {result}")
-    
-    async def clear_cache(self) -> None:
-        """Async: Clear the in-memory cache."""
-        self._cache.clear()
-    
-    async def vacuum(self) -> int:
-        """
-        Async: Remove orphaned temporary files and fix any corrupt files.
-        
-        Returns:
-            Number of fixed or removed files
-        """
-        count = 0
-        
-        try:
-            # Find all temp files
-            loop = asyncio.get_running_loop()
-            temp_files = await loop.run_in_executor(
-                None,
-                lambda: list(self.directory.glob("*.tmp"))
-            )
-            
-            # Delete temp files
-            for temp_file in temp_files:
-                try:
-                    await loop.run_in_executor(None, temp_file.unlink)
-                    count += 1
-                except IOError as e:
-                    logger.error(f"Failed to delete temp file {temp_file}: {e}")
-            
-            # Find all json files
-            json_files = await loop.run_in_executor(
-                None,
-                lambda: list(self.directory.glob("*.json"))
-            )
-            
-            # Check each file for corruption
-            for json_file in json_files:
-                try:
-                    # Try to read the file
-                    if AIOFILES_AVAILABLE:
-                        async with aiofiles.open(json_file, 'r', encoding='utf-8') as f:
-                            data_str = await f.read()
-                            # Just try to parse it to see if it's valid JSON
-                            json.loads(data_str)
-                    else:
-                        data_str = await loop.run_in_executor(
-                            None,
-                            lambda: open(json_file, 'r', encoding='utf-8').read()
-                        )
-                        json.loads(data_str)
-                except (json.JSONDecodeError, IOError) as e:
-                    # File is corrupt, rename it
-                    logger.warning(f"Found corrupt file {json_file}: {e}")
-                    corrupt_path = json_file.with_suffix('.corrupt')
-                    await loop.run_in_executor(
-                        None,
-                        lambda: os.rename(json_file, corrupt_path)
-                    )
-                    count += 1
-                    
-            return count
-        except Exception as e:
-            logger.error(f"Error during vacuum: {e}")
-            raise FileStorageError(f"Failed to vacuum storage: {str(e)}")
-
-
-async def create_file_session_store(
-    directory: Union[str, Path],
-    session_class: Type[T] = Session,
-    auto_save: bool = True
-) -> FileSessionStore[T]:
-    """
-    Create an async file-based session store.
-    
-    Args:
-        directory: Directory where session files will be stored
-        session_class: The Session class to use
-        auto_save: Whether to automatically save on each update
-        
-    Returns:
-        A configured FileSessionStore
-    """
-    store = FileSessionStore(directory, session_class, auto_save)
-    
-    # Optional: Run vacuum on startup to clean any leftover temp files
-    try:
-        fixed_count = await store.vacuum()
-        if fixed_count > 0:
-            logger.info(f"Cleaned up {fixed_count} temporary or corrupt files during store initialization")
-    except Exception as e:
-        logger.warning(f"Error during initial vacuum: {e}")
-        
-    return store

chuk_ai_session_manager/storage/providers/memory.py

@@ -1,96 +0,0 @@
-# chuk_ai_session_manager/storage/providers/memory.py
-"""
-Async in-memory session storage implementation with improved async semantics.
-"""
-from typing import Any, Dict, List, Optional
-import asyncio
-from datetime import datetime
-
-from chuk_ai_session_manager.storage.base import SessionStoreInterface
-
-
-class InMemorySessionStore(SessionStoreInterface):
-    """A simple in-memory store for Session objects with proper async interface.
-    
-    This implementation stores sessions in a dictionary and is not
-    persistent across application restarts. It uses asyncio locks to
-    ensure thread safety when multiple coroutines access the store.
-    """
-    
-    def __init__(self) -> None:
-        """Initialize an empty in-memory store."""
-        self._data: Dict[str, Any] = {}
-        self._lock = asyncio.Lock()  # For thread safety in async operations
-
-    async def get(self, session_id: str) -> Optional[Any]:
-        """Async: Retrieve a session by its ID, or None if not found."""
-        # Read operations don't need locking
-        return self._data.get(session_id)
-
-    async def save(self, session: Any) -> None:
-        """Async: Save or update a session object in the store."""
-        async with self._lock:
-            self._data[session.id] = session
-            
-            # Update metadata timestamp if available
-            if hasattr(session, 'metadata') and hasattr(session.metadata, 'update_timestamp'):
-                await session.metadata.update_timestamp()
-    
-    async def delete(self, session_id: str) -> None:
-        """Async: Delete a session by its ID."""
-        async with self._lock:
-            if session_id in self._data:
-                del self._data[session_id]
-    
-    async def list_sessions(self, prefix: str = "") -> List[str]:
-        """Async: List all session IDs, optionally filtered by prefix."""
-        # Read operations don't need locking
-        if not prefix:
-            return list(self._data.keys())
-        return [sid for sid in self._data.keys() if sid.startswith(prefix)]
-    
-    async def clear(self) -> None:
-        """Async: Clear all sessions from the store."""
-        async with self._lock:
-            self._data.clear()
-            
-    async def get_by_property(self, key: str, value: Any) -> List[Any]:
-        """
-        Async: Find sessions by a specific metadata property value.
-        
-        Args:
-            key: The metadata property key to search for
-            value: The value to match
-            
-        Returns:
-            A list of matching sessions
-        """
-        results = []
-        for session in self._data.values():
-            if (hasattr(session, 'metadata') and 
-                hasattr(session.metadata, 'properties') and
-                session.metadata.properties.get(key) == value):
-                results.append(session)
-        return results
-    
-    async def get_by_state(self, key: str, value: Any) -> List[Any]:
-        """
-        Async: Find sessions by a specific state value.
-        
-        Args:
-            key: The state key to search for
-            value: The value to match
-            
-        Returns:
-            A list of matching sessions
-        """
-        results = []
-        for session in self._data.values():
-            if (hasattr(session, 'state') and 
-                session.state.get(key) == value):
-                results.append(session)
-        return results
-    
-    async def count(self) -> int:
-        """Async: Count the number of sessions in the store."""
-        return len(self._data)