cheshirecat-python-sdk 1.2.1__py3-none-any.whl → 1.7.9__py3-none-any.whl

cheshirecat_python_sdk/endpoints/base.py

@@ -2,6 +2,7 @@ from abc import ABC
 from typing import Dict, Any, List, Tuple, Type
 import requests
 from pydantic import BaseModel
+from requests_toolbelt.sessions import BaseUrlSession
 from websockets import ClientConnection
 
 from cheshirecat_python_sdk.utils import T, deserialize
@@ -21,25 +22,34 @@ class AbstractEndpoint(ABC):
     def format_url(self, endpoint: str) -> str:
         return f"/{self.prefix}/{endpoint}".replace("//", "/")
 
-    def get_http_client(self, agent_id: str | None = None, user_id: str | None = None) -> requests.Session:
-        return self.client.http_client.get_client(agent_id, user_id)
+    def get_http_client(
+        self,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        chat_id: str | None = None,
+    ) -> requests.Session:
+        return self.client.http_client.get_client(agent_id, user_id, chat_id)
 
-    async def get_ws_client(self, agent_id: str | None = None, user_id: str | None = None) -> ClientConnection:
-        return await self.client.ws_client.get_client(agent_id, user_id)
+    def get_http_session(self) -> BaseUrlSession:
+        return self.client.http_client.get_base_session()
+
+    async def get_ws_client(self, agent_id: str, user_id: str, chat_id: str | None = None) -> ClientConnection:
+        return await self.client.ws_client.get_client(agent_id, user_id, chat_id)
 
     def get(
         self,
         endpoint: str,
+        agent_id: str,
         output_class: Type[T] | None = None,
-        agent_id: str | None = None,
-        user_id: str | None = None,
         query: Dict[str, Any] | None = None,
+        user_id: str | None = None,
     ) -> T:
         options = {}
         if query:
             options["params"] = query
 
         response = self.get_http_client(agent_id, user_id).get(endpoint, **options)
+        response.raise_for_status()
 
         if output_class is None:
             return response.json()
@@ -48,24 +58,29 @@ class AbstractEndpoint(ABC):
     def post_json(
         self,
         endpoint: str,
-        output_class: Type[T],
+        agent_id: str,
+        output_class: Type[T] | None = None,
         payload: Dict[str, Any] | None = None,
-        agent_id: str | None = None,
         user_id: str | None = None,
+        chat_id: str | None = None,
     ) -> T:
         options = {}
         if payload:
             options["json"] = payload
 
-        response = self.get_http_client(agent_id, user_id).post(endpoint, **options)
+        response = self.get_http_client(agent_id, user_id, chat_id).post(endpoint, **options)
+        response.raise_for_status()
+
+        if output_class is None:
+            return response.json()
         return deserialize(response.json(), output_class)
 
     def post_multipart(
         self,
         endpoint: str,
-        output_class: Type[T],
+        agent_id: str,
+        output_class: Type[T] | None = None,
         payload: MultipartPayload | None = None,
-        agent_id: str | None = None,
         user_id: str | None = None,
     ) -> T:
         options = {}
@@ -75,24 +90,36 @@ class AbstractEndpoint(ABC):
             options["files"] = payload.files
 
         response = self.get_http_client(agent_id, user_id).post(endpoint, **options)
+        response.raise_for_status()
+
+        if output_class is None:
+            return response.json()
         return deserialize(response.json(), output_class)
 
     def put(
         self,
         endpoint: str,
-        output_class: Type[T],
-        payload: Dict[str, Any],
-        agent_id: str | None = None,
+        agent_id: str,
+        output_class: Type[T] | None = None,
+        payload: Dict[str, Any] | None = None,
         user_id: str | None = None,
     ) -> T:
-        response = self.get_http_client(agent_id, user_id).put(endpoint, json=payload)
+        options = {}
+        if payload:
+            options["json"] = payload
+
+        response = self.get_http_client(agent_id, user_id).put(endpoint, **options)
+        response.raise_for_status()
+
+        if output_class is None:
+            return response.json()
         return deserialize(response.json(), output_class)
 
     def delete(
         self,
         endpoint: str,
-        output_class: Type[T],
-        agent_id: str | None = None,
+        agent_id: str,
+        output_class: Type[T] | None = None,
         user_id: str | None = None,
         payload: Dict[str, Any] | None = None,
     ) -> T:
@@ -101,4 +128,8 @@ class AbstractEndpoint(ABC):
             options["json"] = payload
 
         response = self.get_http_client(agent_id, user_id).delete(endpoint, **options)
+        response.raise_for_status()
+
+        if output_class is None:
+            return response.json()
         return deserialize(response.json(), output_class)

cheshirecat_python_sdk/endpoints/chunker.py

@@ -9,7 +9,7 @@ class ChunkerEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/chunking"
 
-    def get_chunkers_settings(self, agent_id: str | None = None) -> FactoryObjectSettingsOutput:
+    def get_chunkers_settings(self, agent_id: str) -> FactoryObjectSettingsOutput:
         """
         Get all chunker settings for the agent specified by agent_id
         :param agent_id: The agent id
@@ -17,11 +17,11 @@ class ChunkerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/settings"),
-            FactoryObjectSettingsOutput,
             agent_id,
+            output_class=FactoryObjectSettingsOutput,
         )
 
-    def get_chunker_settings(self, chunker: str, agent_id: str | None = None) -> FactoryObjectSettingOutput:
+    def get_chunker_settings(self, chunker: str, agent_id: str) -> FactoryObjectSettingOutput:
         """
         Get the chunker settings for the chunker specified by chunker and agent_id
         :param chunker: The name of the chunker
@@ -30,23 +30,23 @@ class ChunkerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url(f"/settings/{chunker}"),
-            FactoryObjectSettingOutput,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
         )
 
     def put_chunker_settings(
-        self, chunker: str, values: Dict[str, Any], agent_id: str | None = None
+        self, chunker: str, agent_id: str, values: Dict[str, Any]
     ) -> FactoryObjectSettingOutput:
         """
         Update the chunker settings for the chunker specified by chunker and agent_id
         :param chunker: The name of the chunker
-        :param values: The new settings
         :param agent_id: The agent id
+        :param values: The new settings
         :return: FactoryObjectSettingOutput, the updated chunker settings
         """
         return self.put(
             self.format_url(f"/settings/{chunker}"),
-            FactoryObjectSettingOutput,
-            values,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
         )

cheshirecat_python_sdk/endpoints/conversation.py

@@ -0,0 +1,83 @@
+from typing import List
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.conversations import (
+    ConversationHistoryOutput,
+    ConversationDeleteOutput,
+    ConversationsResponse,
+    ConversationNameChangeOutput,
+)
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class ConversationEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/conversation"
+
+    def get_conversation_history(self, agent_id: str, user_id: str, chat_id: str) -> ConversationHistoryOutput:
+        """
+        This endpoint returns the conversation history.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationHistoryOutput, a list of conversation history entries.
+        """
+        return self.get(
+            self.format_url(chat_id),
+            agent_id,
+            user_id=user_id,
+            output_class=ConversationHistoryOutput,
+        )
+
+    def get_conversations(self, agent_id: str, user_id: str) -> List[ConversationsResponse]:
+        """
+        This endpoint returns the attributes of the different conversations, given the `agent_id` and the `user_id`.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :return: List[ConversationsResponse], a list of conversation attributes.
+        """
+        response = self.get_http_client(agent_id, user_id).get(self.prefix)
+        response.raise_for_status()
+
+        return [deserialize(item, ConversationsResponse) for item in response.json()]
+
+    def delete_conversation(self, agent_id: str, user_id: str, chat_id: str) -> ConversationDeleteOutput:
+        """
+        This endpoint deletes the conversation.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationDeleteOutput, a message indicating whether the conversation was deleted.
+        """
+        return self.delete(
+            self.format_url(chat_id),
+            agent_id,
+            output_class=ConversationDeleteOutput,
+            user_id=user_id,
+        )
+
+    def post_conversation_name(
+        self,
+        name: str,
+        agent_id: str,
+        user_id: str,
+        chat_id: str,
+    ) -> ConversationNameChangeOutput:
+        """
+        This endpoint creates a new element in the conversation history.
+        :param name: The new name to assign to the conversation
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationNameChangeOutput, a message indicating whether the conversation name was changed.
+        """
+        payload = {"name": name}
+
+        return self.post_json(
+            self.format_url(chat_id),
+            agent_id,
+            output_class=ConversationNameChangeOutput,
+            payload=payload,
+            user_id=user_id,
+        )

cheshirecat_python_sdk/endpoints/custom_endpoint.py

@@ -0,0 +1,57 @@
+from typing import Any, Dict
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+
+
+class CustomEndpoint(AbstractEndpoint):
+    def get_custom(
+        self, url: str, agent_id: str, user_id: str | None = None, query: Dict[str, Any] | None = None
+    ) -> Any:
+        """
+        This method is used to trigger a custom endpoint with GET method
+        :param url: The url of the custom endpoint to trigger
+        :param agent_id: The id of the agent to get settings for (optional)
+        :param user_id: The id of the user to get settings for (optional)
+        :param query: The query parameters to send to the custom endpoint (optional)
+        :return Any, the response from the custom endpoint
+        """
+        return self.get(url, agent_id, user_id=user_id, query=query)
+
+    def post_custom(
+        self, url: str, agent_id: str, payload: Dict[str, Any] | None = None, user_id: str | None = None
+    ) -> Any:
+        """
+        This method is used to trigger a custom endpoint with POST method
+        :param url: The url of the custom endpoint to trigger
+        :param agent_id: The id of the agent to get settings for (optional)
+        :param payload: The payload to send to the custom endpoint (optional)
+        :param user_id: The id of the user to get settings for (optional)
+        :return Any, the response from the custom endpoint
+        """
+        return self.post_json(url, agent_id, payload=payload, user_id=user_id)
+
+    def put_custom(
+        self, url: str, agent_id: str, payload: Dict[str, Any] | None = None, user_id: str | None = None
+    ) -> Any:
+        """
+        The method is used to trigger a custom endpoint with PUT method
+        :param url: The url of the custom endpoint to trigger
+        :param agent_id: The id of the agent to get settings for (optional)
+        :param payload: The payload to send to the custom endpoint (optional)
+        :param user_id: The id of the user to get settings for (optional)
+        :return Any, the response from the custom endpoint
+        """
+        return self.put(url, agent_id, payload=payload, user_id=user_id)
+
+    def delete_custom(
+        self, url: str, agent_id: str, payload: Dict[str, Any] | None = None, user_id: str | None = None
+    ) -> Any:
+        """
+        This method is used to trigger a custom endpoint with DELETE method
+        :param url: The url of the custom endpoint to trigger
+        :param agent_id: The id of the agent to get settings for (optional)
+        :param payload: The payload to send to the custom endpoint (optional)
+        :param user_id: The id of the user to get settings for (optional)
+        :return Any, the response from the custom endpoint
+        """
+        return self.delete(url, agent_id, payload=payload, user_id=user_id)

cheshirecat_python_sdk/endpoints/embedder.py

@@ -16,8 +16,8 @@ class EmbedderEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/settings"),
-            FactoryObjectSettingsOutput,
             self.system_id,
+            output_class=FactoryObjectSettingsOutput,
         )
 
     def get_embedder_settings(self, embedder: str) -> FactoryObjectSettingOutput:
@@ -28,8 +28,8 @@ class EmbedderEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url(f"/settings/{embedder}"),
-            FactoryObjectSettingOutput,
             self.system_id,
+            output_class=FactoryObjectSettingOutput,
         )
 
     def put_embedder_settings(self, embedder: str, values: Dict[str, Any]) -> FactoryObjectSettingOutput:
@@ -41,7 +41,7 @@ class EmbedderEndpoint(AbstractEndpoint):
         """
         return self.put(
             self.format_url(f"/settings/{embedder}"),
-            FactoryObjectSettingOutput,
-            values,
             self.system_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
         )

cheshirecat_python_sdk/endpoints/file_manager.py

@@ -1,7 +1,9 @@
 from typing import Dict, Any
+from requests import Response
 
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
 from cheshirecat_python_sdk.models.api.factories import FactoryObjectSettingOutput, FactoryObjectSettingsOutput
+from cheshirecat_python_sdk.models.api.file_managers import FileManagerAttributes, FileManagerDeletedFiles
 
 
 class FileManagerEndpoint(AbstractEndpoint):
@@ -9,7 +11,7 @@ class FileManagerEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/file_manager"
 
-    def get_file_managers_settings(self, agent_id: str | None = None) -> FactoryObjectSettingsOutput:
+    def get_file_managers_settings(self, agent_id: str) -> FactoryObjectSettingsOutput:
         """
         Get all file managers settings for the agent specified by agent_id
         :param agent_id: The agent id
@@ -17,11 +19,11 @@ class FileManagerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/settings"),
-            FactoryObjectSettingsOutput,
             agent_id,
+            output_class=FactoryObjectSettingsOutput,
         )
 
-    def get_file_manager_settings(self, file_manager: str, agent_id: str | None = None) -> FactoryObjectSettingOutput:
+    def get_file_manager_settings(self, file_manager: str, agent_id: str) -> FactoryObjectSettingOutput:
         """
         Get the settings of a file manager by name for the agent specified by agent_id
         :param file_manager: str, the name of the file manager
@@ -30,23 +32,72 @@ class FileManagerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url(f"/settings/{file_manager}"),
-            FactoryObjectSettingOutput,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
         )
 
     def put_file_manager_settings(
-        self, file_manager: str, values: Dict[str, Any], agent_id: str | None = None
+        self, file_manager: str, agent_id: str, values: Dict[str, Any]
     ) -> FactoryObjectSettingOutput:
         """
         Update the settings of a file manager by name with the given values, for the agent specified by agent_id
         :param file_manager: str, the name of the file manager
-        :param values: Dict[str, Any], the values to update
         :param agent_id: The agent id
+        :param values: Dict[str, Any], the values to update
         :return: FactoryObjectSettingOutput, the updated settings of the file manager
         """
         return self.put(
             self.format_url(f"/settings/{file_manager}"),
-            FactoryObjectSettingOutput,
-            values,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
+        )
+
+    def get_file_manager_attributes(self, agent_id: str) -> FileManagerAttributes:
+        """
+        Get the attributes of the file manager for the agent specified by agent_id
+        :param agent_id: The agent id
+        :return: FileManagerAttributes, the attributes of the file manager
+        """
+        return self.get(self.prefix, agent_id, output_class=FileManagerAttributes)
+
+    def get_file(self, agent_id: str, file_name: str) -> Response:
+        """
+        Download a file from the file manager for the agent specified by agent_id
+        :param agent_id: The agent id
+        :param file_name: The name of the file to download
+        :return: Response, the response containing the file content
+        """
+        response = self.get_http_client(agent_id).get(
+            self.format_url(f"/files/{file_name}"),
+            stream=True,
+            headers={"Accept": "application/octet-stream"}
+        )
+        response.raise_for_status()
+
+        return response
+
+    def delete_file(self, agent_id: str, file_name: str) -> FileManagerDeletedFiles:
+        """
+        Download a file from the file manager for the agent specified by agent_id
+        :param agent_id: The agent id
+        :param file_name: The name of the file to delete
+        :return: FileManagerDeletedFiles, the response containing info about the deleted file
+        """
+        return self.delete(
+            self.format_url(f"/files/{file_name}"),
+            agent_id,
+            output_class=FileManagerDeletedFiles,
+        )
+
+    def delete_files(self, agent_id: str) -> FileManagerDeletedFiles:
+        """
+        Download a file from the file manager for the agent specified by agent_id
+        :param agent_id: The agent id
+        :return: bool, True if all files were deleted successfully
+        """
+        return self.delete(
+            self.format_url("/files"),
+            agent_id,
+            output_class=FileManagerDeletedFiles,
         )

cheshirecat_python_sdk/endpoints/health_check.py

@@ -0,0 +1,22 @@
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+
+class HealthCheckEndpoint(AbstractEndpoint):
+    def liveness(self):
+        """
+        This endpoint is used to check if the server is running.
+        :return: dict, the status of the server.
+        """
+        response = self.get_http_session().get("/health/liveness")
+        response.raise_for_status()
+
+        return response.json()
+
+    def readiness(self):
+        """
+        This endpoint is used to check if the server is running.
+        :return: dict, the status of the server.
+        """
+        response = self.get_http_session().get("/health/readiness")
+        response.raise_for_status()
+
+        return response.json()

cheshirecat_python_sdk/endpoints/large_language_model.py

@@ -9,7 +9,7 @@ class LargeLanguageModelEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/llm"
 
-    def get_large_language_models_settings(self, agent_id: str | None = None) -> FactoryObjectSettingsOutput:
+    def get_large_language_models_settings(self, agent_id: str) -> FactoryObjectSettingsOutput:
         """
         Get all large language model settings for the agent specified by agent_id
         :param agent_id: The agent id
@@ -17,11 +17,11 @@ class LargeLanguageModelEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/settings"),
-            FactoryObjectSettingsOutput,
             agent_id,
+            output_class=FactoryObjectSettingsOutput,
         )
 
-    def get_large_language_model_settings(self, llm: str, agent_id: str | None = None) -> FactoryObjectSettingOutput:
+    def get_large_language_model_settings(self, llm: str, agent_id: str) -> FactoryObjectSettingOutput:
         """
         Get the large language model settings for the large language model specified by llm and agent_id
         :param llm: The name of the large language model
@@ -30,23 +30,23 @@ class LargeLanguageModelEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url(f"/settings/{llm}"),
-            FactoryObjectSettingOutput,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
         )
 
     def put_large_language_model_settings(
-        self, llm: str, values: Dict[str, Any], agent_id: str | None = None
+        self, llm: str, agent_id: str, values: Dict[str, Any]
     ) -> FactoryObjectSettingOutput:
         """
         Update the large language model settings for the large language model specified by llm and agent_id
         :param llm: The name of the large language model
-        :param values: The new settings
         :param agent_id: The agent id
+        :param values: The new settings
         :return: FactoryObjectSettingOutput, the updated large language model settings
         """
         return self.put(
             self.format_url(f"/settings/{llm}"),
-            FactoryObjectSettingOutput,
-            values,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
         )