recallrai 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

recallrai/session.py

@@ -6,13 +6,19 @@ Session management functionality for the RecallrAI SDK.
 """
 
 from typing import List
-from .utils import HTTPClient, RecallrAIError
+from .utils import HTTPClient
 from .models import (
     Context,
     Message,
     SessionStatus,
     MessageRole
 )
+from .exceptions import (
+    UserNotFoundError,
+    SessionNotFoundError,
+    InvalidSessionStateError,
+    RecallrAIError
+)
 from logging import getLogger
 
 logger = getLogger(__name__)
@@ -51,21 +57,16 @@ class Session:
             message: Content of the user message
 
         Raises:
-            BadRequestError: If the session is already processed
-            NotFoundError: If the session or user is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            InvalidSessionStateError: If the session is already processed or processing
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
-        # Check the status of session
-        status = self.get_status()
-        if status == SessionStatus.PROCESSED:
-            raise RecallrAIError("Cannot add message to a session that has already been processed")
-        elif status == SessionStatus.PROCESSING:
-            raise RecallrAIError("Cannot add message to a session that is currently being processed")
-        
-        # Add the user message
-        self._http.post(
-            f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/add-message",
-            data={"message": message, "role": MessageRole.USER},
-        )
+        self._add_message(message, MessageRole.USER)
 
     def add_assistant_message(self, message: str) -> None:
         """
@@ -75,21 +76,56 @@ class Session:
             message: Content of the assistant message
 
         Raises:
-            BadRequestError: If the session is already processed
-            NotFoundError: If the session or user is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            InvalidSessionStateError: If the session is already processed or processing
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
-        # Check the status of session
-        status = self.get_status()
-        if status == SessionStatus.PROCESSED:
-            raise RecallrAIError("Cannot add message to a session that has already been processed")
-        elif status == SessionStatus.PROCESSING:
-            raise RecallrAIError("Cannot add message to a session that is currently being processed")
+        self._add_message(message, MessageRole.ASSISTANT)
+
+    def _add_message(self, message: str, role: MessageRole) -> None:
+        """
+        Internal helper to add a message to the session.
         
-        # Add the assistant message
-        self._http.post(
+        Args:
+            message: Content of the message
+            role: Role of the message sender
+            
+        Raises:
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            InvalidSessionStateError: If the session is already processed or processing
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
+        """
+        response = self._http.post(
             f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/add-message",
-            data={"message": message, "role": MessageRole.ASSISTANT},
+            data={"message": message, "role": role.value},
         )
+        
+        if response.status_code == 404:
+            # Check if it's a user not found or session not found error
+            detail = response.json().get('detail', '')
+            if f"User {self.user_id} not found" in detail:
+                raise UserNotFoundError(user_id=self.user_id)
+            else:
+                raise SessionNotFoundError(session_id=self.session_id)
+        elif response.status_code == 400:
+            raise InvalidSessionStateError(
+                message=f"Cannot add message to session with status {self.get_status()}",
+            )
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to add message: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
 
     def get_context(self) -> Context:
         """
@@ -102,17 +138,36 @@ class Session:
             Context information with the memory text and whether memory was used
 
         Raises:
-            NotFoundError: If the session or user is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
+        response = self._http.get(
+            f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/context"
+        )
+        
+        if response.status_code == 404:
+            # Check if it's a user not found or session not found error
+            detail = response.json().get('detail', '')
+            if f"User {self.user_id} not found" in detail:
+                raise UserNotFoundError(user_id=self.user_id)
+            else:
+                raise SessionNotFoundError(session_id=self.session_id)
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to get context: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
         status = self.get_status()
         if status == SessionStatus.PROCESSED:
             logger.warning("Cannot add message to a session that has already been processed")
         elif status == SessionStatus.PROCESSING:
             logger.warning("Cannot add message to a session that is currently being processed")
-        response = self._http.get(
-            f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/context"
-        )
-        return Context.from_api_response(response)
+        return Context.from_api_response(response.json())
 
     def process(self) -> None:
         """
@@ -122,21 +177,35 @@ class Session:
         the user's memory.
 
         Raises:
-            BadRequestError: If the session is already processed or being processed
-            NotFoundError: If the session or user is not found
-            SessionProcessingError: If there is an error during processing
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            InvalidSessionStateError: If the session is already processed or being processed
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
-        # Check the status of session
-        status = self.get_status()
-        if status == SessionStatus.PROCESSED:
-            raise RecallrAIError("Cannot process a session that has already been processed")
-        elif status == SessionStatus.PROCESSING:
-            raise RecallrAIError("Cannot process a session that is currently being processed")
-        
-        # Process the session
-        self._http.post(
+        response = self._http.post(
             f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/process"
         )
+        
+        if response.status_code == 404:
+            # Check if it's a user not found or session not found error
+            detail = response.json().get('detail', '')
+            if f"User {self.user_id} not found" in detail:
+                raise UserNotFoundError(user_id=self.user_id)
+            else:
+                raise SessionNotFoundError(session_id=self.session_id)
+        elif response.status_code == 400:
+            raise InvalidSessionStateError(
+                message=f"{response.json().get('detail', f'Cannot process session with status {self.get_status()}')}",
+            )
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to process session: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
 
     def get_status(self) -> SessionStatus:
         """
@@ -146,12 +215,32 @@ class Session:
             SessionStatus: The current status of the session
 
         Raises:
-            NotFoundError: If the session or user is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
         response = self._http.get(
             f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/status"
         )
-        return SessionStatus(response["status"])
+        
+        if response.status_code == 404:
+            # Check if it's a user not found or session not found error
+            detail = response.json().get('detail', '')
+            if f"User {self.user_id} not found" in detail:
+                raise UserNotFoundError(user_id=self.user_id)
+            else:
+                raise SessionNotFoundError(session_id=self.session_id)
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to get session status: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
+            
+        return SessionStatus(response.json()["status"])
 
     def get_messages(self) -> List[Message]:
         """
@@ -161,9 +250,30 @@ class Session:
             List of messages in the session
 
         Raises:
-            NotFoundError: If the session or user is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
         response = self._http.get(
             f"/api/v1/users/{self.user_id}/sessions/{self.session_id}/messages"
         )
-        return [Message(**msg) for msg in response["messages"]]
+        
+        if response.status_code == 404:
+            # Check if it's a user not found or session not found error
+            detail = response.json().get('detail', '')
+            if f"User {self.user_id} not found" in detail:
+                raise UserNotFoundError(user_id=self.user_id)
+            else:
+                raise SessionNotFoundError(session_id=self.session_id)
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to get messages: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
+            
+        data = response.json()
+        return [Message(**msg) for msg in data["messages"]]

recallrai/user.py

@@ -6,6 +6,15 @@ from typing import Any, Dict, Optional
 from .utils import HTTPClient
 from .models import User as UserModel, SessionList
 from .session import Session
+from .exceptions import (
+    UserNotFoundError,
+    UserAlreadyExistsError,
+    SessionNotFoundError,
+    RecallrAIError
+)
+from logging import getLogger
+
+logger = getLogger(__name__)
 
 class User:
     """
@@ -46,18 +55,33 @@ class User:
             The updated user object
 
         Raises:
-            NotFoundError: If the user is not found
-            ValidationError: If the new_user_id is invalid
-            BadRequestError: If a user with the new_user_id already exists
+            UserNotFoundError: If the user is not found
+            UserAlreadyExistsError: If a user with the new_user_id already exists
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
         data = {}
         if new_metadata is not None:
-            data["new_metadata"] = new_metadata
+            data["metadata"] = new_metadata
         if new_user_id is not None:
             data["new_user_id"] = new_user_id
             
         response = self._http.put(f"/api/v1/users/{self.user_id}", data=data)
-        updated_data = UserModel.from_api_response(response)
+        
+        if response.status_code == 404:
+            raise UserNotFoundError(user_id=self.user_id)
+        elif response.status_code == 409:
+            raise UserAlreadyExistsError(user_id=new_user_id)
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to update user: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
+            
+        updated_data = UserModel.from_api_response(response.json())
         
         # Update internal state
         self._user_data = updated_data
@@ -72,9 +96,22 @@ class User:
         Delete this user.
 
         Raises:
-            NotFoundError: If the user is not found
+            UserNotFoundError: If the user is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
-        self._http.delete(f"/api/v1/users/{self.user_id}")
+        response = self._http.delete(f"/api/v1/users/{self.user_id}")
+        
+        if response.status_code == 404:
+            raise UserNotFoundError(user_id=self.user_id)
+        elif response.status_code != 204:
+            raise RecallrAIError(
+                message=f"Failed to delete user: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
 
     def create_session(self, auto_process_after_minutes: int = -1) -> Session:
         """
@@ -87,14 +124,27 @@ class User:
             A Session object to interact with the created session
 
         Raises:
-            ValidationError: If auto_process_after_minutes is invalid
+            UserNotFoundError: If the user is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
         response = self._http.post(
             f"/api/v1/users/{self.user_id}/sessions",
             data={"auto_process_after_minutes": auto_process_after_minutes},
         )
         
-        session_id = response["session_id"]
+        if response.status_code == 404:
+            raise UserNotFoundError(user_id=self.user_id)
+        elif response.status_code != 201:
+            raise RecallrAIError(
+                message=f"Failed to create session: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
+        
+        session_id = response.json()["session_id"]
         return Session(self._http, self.user_id, session_id)
 
     def get_session(self, session_id: str) -> Session:
@@ -108,9 +158,23 @@ class User:
             A Session object to interact with the session
 
         Raises:
-            NotFoundError: If the session is not found
+            UserNotFoundError: If the user is not found
+            SessionNotFoundError: If the session is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
-        return Session(self._http, self.user_id, session_id)
+        # Verify the session exists by checking its status
+        session = Session(self._http, self.user_id, session_id)
+        try:
+            session.get_status()  # This will raise appropriate errors if the session doesn't exist
+            return session
+        except SessionNotFoundError:
+            raise
+        except Exception as e:
+            raise RecallrAIError(f"Error retrieving session: {str(e)}")
 
     def list_sessions(self, offset: int = 0, limit: int = 10) -> SessionList:
         """
@@ -122,9 +186,26 @@ class User:
 
         Returns:
             List of sessions with pagination info
+
+        Raises:
+            UserNotFoundError: If the user is not found
+            AuthenticationError: If the API key or project ID is invalid
+            InternalServerError: If the server encounters an error
+            NetworkError: If there are network issues
+            TimeoutError: If the request times out
+            RecallrAIError: For other API-related errors
         """
         response = self._http.get(
             f"/api/v1/users/{self.user_id}/sessions",
             params={"offset": offset, "limit": limit},
         )
-        return SessionList.from_api_response(response)
+        
+        if response.status_code == 404:
+            raise UserNotFoundError(user_id=self.user_id)
+        elif response.status_code != 200:
+            raise RecallrAIError(
+                message=f"Failed to list sessions: {response.json().get('detail', 'Unknown error')}",
+                http_status=response.status_code
+            )
+            
+        return SessionList.from_api_response(response.json())

recallrai/utils/__init__.py

@@ -1,10 +1,8 @@
 # Path: recallrai/utils/__init__.py
 # Description: Package initialization for utilities
 
-from .http import HTTPClient
-from .exceptions import RecallrAIError
+from .http_client import HTTPClient
 
 __all__ = [
     "HTTPClient",
-    "RecallrAIError",
-]
+]

recallrai/utils/http_client.py

@@ -0,0 +1,123 @@
+# Path: recallrai/utils/http.py
+# Description: HTTP client utilities for the RecallrAI SDK
+
+from httpx import Response, Client, TimeoutException, NetworkError, ConnectError
+from typing import Any, Dict, Optional
+from ..exceptions import (
+    TimeoutError, 
+    NetworkError as CustomNetworkError, 
+    ConnectionError,
+    ValidationError,
+    InternalServerError,
+    AuthenticationError,
+)
+
+class HTTPClient:
+    """HTTP client for making requests to the RecallrAI API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        project_id: str,
+        base_url: str,
+        timeout: int = 30,
+    ):
+        """
+        Initialize the HTTP client.
+
+        Args:
+            api_key: Your RecallrAI API key
+            project_id: Your project ID
+            base_url: The base URL for the RecallrAI API
+            timeout: Request timeout in seconds
+        """
+        self.api_key = api_key
+        self.project_id = project_id
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.client = Client(
+            timeout=self.timeout,
+            headers={
+                "X-Api-Key": self.api_key,
+                "X-Project-Id": self.project_id,
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "User-Agent": "RecallrAI-Python-SDK",
+                # TODO: "SDK-Version": "0.1.0",
+            },
+        )
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Response:
+        """
+        Make a request to the RecallrAI API.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            path: API endpoint path
+            params: Query parameters
+            data: Request body data
+
+        Returns:
+            The parsed JSON response
+        """
+        url = f"{self.base_url}{path}"
+        
+        # Filter out None values in params and data
+        if params:
+            params = {k: v for k, v in params.items() if v is not None}
+        
+        if data:
+            data = {k: v for k, v in data.items() if v is not None}
+        
+        try:
+            response = self.client.request(
+                method=method,
+                url=url,
+                params=params,
+                json=data,
+            )
+            if response.status_code == 422:
+                raise ValidationError(
+                    details=response.json()["detail"],
+                )
+            elif response.status_code == 500:
+                raise InternalServerError(
+                    details=response.json()["detail"],
+                )
+            elif response.status_code == 401:
+                raise AuthenticationError(
+                    details=response.json()["detail"],
+                )
+            
+            return response
+        except TimeoutException as e:
+            raise TimeoutError(f"Request timed out: {e}")
+        except NetworkError as e:
+            raise CustomNetworkError(f"Network error occurred: {e}")
+        except ConnectError as e:
+            raise ConnectionError(f"Failed to connect to the API: {e}")
+        except Exception as e:
+            # Handle other exceptions as needed
+            raise e
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Response:
+        """Make a GET request."""
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Response:
+        """Make a POST request."""
+        return self.request("POST", path, data=data)
+
+    def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Response:
+        """Make a PUT request."""
+        return self.request("PUT", path, data=data)
+
+    def delete(self, path: str) -> Response:
+        """Make a DELETE request."""
+        return self.request("DELETE", path)