cheshirecat-python-sdk 1.4.0__tar.gz → 1.7.8__tar.gz

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cheshirecat-python-sdk
-Version: 1.4.0
+Version: 1.7.8
 Summary: Python SDK for the Cloud-ready fork of the Cheshire Cat
 Project-URL: Repository, https://github.com/matteocacciola/cheshirecat-python-sdk
 Project-URL: Documentation, https://github.com/matteocacciola/cheshirecat-python-sdk#README

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/client.py

@@ -2,6 +2,7 @@ from cheshirecat_python_sdk.clients import HttpClient, WSClient
 from cheshirecat_python_sdk.configuration import Configuration
 from cheshirecat_python_sdk.endpoints import (
     AdminsEndpoint,
+    AuthEndpoint,
     AuthHandlerEndpoint,
     ChunkerEndpoint,
     ConversationEndpoint,
@@ -14,6 +15,7 @@ from cheshirecat_python_sdk.endpoints import (
     PluginsEndpoint,
     RabbitHoleEndpoint,
     UsersEndpoint,
+    UtilsEndpoint,
     VectorDatabaseEndpoint,
     HealthCheckEndpoint,
 )
@@ -54,6 +56,10 @@ class CheshireCatClient:
     def admins(self):
         return AdminsEndpoint(self)
 
+    @property
+    def auth(self):
+        return AuthEndpoint(self)
+
     @property
     def auth_handler(self):
         return AuthHandlerEndpoint(self)
@@ -98,6 +104,10 @@ class CheshireCatClient:
     def users(self):
         return UsersEndpoint(self)
 
+    @property
+    def utils(self):
+        return UtilsEndpoint(self)
+
     @property
     def custom(self):
         return CustomEndpoint(self)

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/clients/http_client.py

@@ -15,8 +15,9 @@ class HttpClient:
         self.port = port
         self.apikey = apikey
         self.token = None
-        self.user_id = None
         self.agent_id = None
+        self.user_id = None
+        self.chat_id = None
         self.is_https = is_https
         self.headers = {}
 
@@ -38,23 +39,33 @@ class HttpClient:
     def __before_secure_request(self):
         if self.apikey:
             self.headers["Authorization"] = f"Bearer {self.apikey}"
-        if self.user_id:
-            self.headers["user_id"] = self.user_id
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.user_id:
+            self.headers["X-User-ID"] = self.user_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
     def __before_jwt_request(self):
         if self.token:
             self.headers["Authorization"] = f"Bearer {self.token}"
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
-    def get_client(self, agent_id: str | None = None, user_id: str | None = None) -> BaseUrlSession:
+    def get_client(
+        self,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        chat_id: str | None = None,
+    ) -> BaseUrlSession:
         if not self.apikey and not self.token:
             raise ValueError("You must provide an apikey or a token")
 
         self.agent_id = agent_id
         self.user_id = user_id
+        self.chat_id = chat_id
 
         for middleware in self.middlewares:
             middleware()

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/clients/websocket_client.py

@@ -22,28 +22,37 @@ class WSClient:
         self.token = token
         return self
 
-    def get_ws_uri(self, agent_id: str, user_id: str) -> str:
+    def get_ws_uri(
+        self,
+        agent_id: str,
+        user_id: str,
+        chat_id: str | None = None,
+    ) -> str:
         query = {"user_id": user_id}
-        if self.token:
-            query["token"] = self.token
-        elif self.apikey:
-            query["apikey"] = self.apikey
-        else:
-            raise ValueError("You must provide an apikey or a token")
 
         scheme = "wss" if self.is_wss else "ws"
         path = f"ws/{agent_id}"
+        if chat_id:
+            path += f"/{chat_id}"
+
         query_string = urlencode(query)
         port_suffix = f":{self.port}" if self.port else ""
 
         return f"{scheme}://{self.host}{port_suffix}/{path}?{query_string}"
 
-    async def get_client(self, agent_id: str, user_id: str) -> ClientConnection:
-        uri = self.get_ws_uri(agent_id, user_id)
+    async def get_client(self, agent_id: str, user_id: str, chat_id: str | None = None) -> ClientConnection:
+        uri = self.get_ws_uri(agent_id, user_id, chat_id)
         if self.ws_client is None:
             try:
+                if self.token:
+                    headers = {"Authorization": f"Bearer {self.token}"}
+                elif self.apikey:
+                    headers = {"Authorization": f"Bearer {self.apikey}"}
+                else:
+                    raise ValueError("You must provide an apikey or a token")
+
                 # Create a WebSocket connection
-                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000)
+                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000, additional_headers=headers)
                 self.ws_client = websocket
             except InvalidURI as e:
                 raise ValueError(f"Invalid WebSocket URI: {uri}") from e

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/__init__.py

@@ -1,4 +1,5 @@
 from cheshirecat_python_sdk.endpoints.admins import AdminsEndpoint
+from cheshirecat_python_sdk.endpoints.auth import AuthEndpoint
 from cheshirecat_python_sdk.endpoints.auth_handler import AuthHandlerEndpoint
 from cheshirecat_python_sdk.endpoints.chunker import ChunkerEndpoint
 from cheshirecat_python_sdk.endpoints.conversation import ConversationEndpoint
@@ -11,5 +12,6 @@ from cheshirecat_python_sdk.endpoints.message import MessageEndpoint
 from cheshirecat_python_sdk.endpoints.plugins import PluginsEndpoint
 from cheshirecat_python_sdk.endpoints.rabbit_hole import RabbitHoleEndpoint
 from cheshirecat_python_sdk.endpoints.users import UsersEndpoint
+from cheshirecat_python_sdk.endpoints.utils import UtilsEndpoint
 from cheshirecat_python_sdk.endpoints.vector_database import VectorDatabaseEndpoint
 from cheshirecat_python_sdk.endpoints.health_check import HealthCheckEndpoint

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/admins.py

@@ -1,10 +1,8 @@
-from typing import List, Any
+from typing import List
 
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint, MultipartPayload
 from cheshirecat_python_sdk.models.api.admins import (
     AdminOutput,
-    ResetOutput,
-    CreatedOutput,
     PluginInstallOutput,
     PluginInstallFromRegistryOutput,
     PluginDetailsOutput,
@@ -12,7 +10,6 @@ from cheshirecat_python_sdk.models.api.admins import (
 )
 from cheshirecat_python_sdk.models.api.nested.plugins import PluginSettingsOutput
 from cheshirecat_python_sdk.models.api.plugins import PluginCollectionOutput, PluginsSettingsOutput, PluginToggleOutput
-from cheshirecat_python_sdk.models.api.tokens import TokenOutput
 from cheshirecat_python_sdk.utils import deserialize, file_attributes
 
 
@@ -21,35 +18,6 @@ class AdminsEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/admins"
 
-    def token(self, username: str, password: str) -> TokenOutput:
-        """
-        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system.
-        When the token expires, the user must request a new token.
-        :param username: The username of the user.
-        :param password: The password of the user.
-        :return: TokenOutput, the token of the user.
-        """
-        response = self.get_http_session().post(
-            self.format_url("/auth/token"),
-            json={"username": username, "password": password},
-        )
-        response.raise_for_status()
-
-        result = deserialize(response.json(), TokenOutput)
-        self.client.add_token(result.access_token)
-        return result
-
-    def get_available_permissions(self) -> dict[int | str, Any]:
-        """
-        This endpoint is used to get a list of available permissions in the system. The permissions are used to define
-        the access rights of the users in the system. The permissions are defined by the system administrator.
-        :return array<int|string, Any>, the available permissions
-        """
-        response = self.get_http_client().get(self.format_url("/auth/available-permissions"))
-        response.raise_for_status()
-
-        return response.json()
-
     def post_admin(self, username: str, password: str, permissions: dict | None = None) -> AdminOutput:
         """
         Create a new admin user.
@@ -126,44 +94,6 @@ class AdminsEndpoint(AbstractEndpoint):
         """
         return self.delete(self.format_url(f"/users/{admin_id}"), self.system_id, output_class=AdminOutput)
 
-    def post_factory_reset(self) -> ResetOutput:
-        """
-        Reset the system to the factory settings.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/factory/reset/"), self.system_id, output_class=ResetOutput)
-
-    def get_agents(self) -> List[str]:
-        """
-        Get a list of all agents.
-        :return: List[str], the IDs of the agents.
-        """
-        return self.get(self.format_url("/utils/agents/"), self.system_id)
-
-    def post_agent_create(self, agent_id: str) -> CreatedOutput:
-        """
-        Create a new agent.
-        :param agent_id: The ID of the agent.
-        :return: CreatedOutput, the details of the agent.
-        """
-        return self.post_json(self.format_url("/utils/agent/create/"), agent_id, output_class=CreatedOutput)
-
-    def post_agent_reset(self, agent_id: str) -> ResetOutput:
-        """
-        Reset an agent to the factory settings.
-        :param agent_id: The ID of the agent.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/agent/reset/"), agent_id, output_class=ResetOutput)
-
-    def post_agent_destroy(self, agent_id: str) -> ResetOutput:
-        """
-        Destroy an agent.
-        :param agent_id: The ID of the agent.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/agent/destroy/"), agent_id, output_class=ResetOutput)
-
     def get_available_plugins(self, plugin_name: str | None = None) -> PluginCollectionOutput:
         """
         Get a list of all available plugins.

cheshirecat_python_sdk-1.7.8/cheshirecat_python_sdk/endpoints/auth.py

@@ -0,0 +1,54 @@
+from typing import Any
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.tokens import TokenOutput, MeOutput
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class AuthEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/auth"
+
+    def token(self, username: str, password: str) -> TokenOutput:
+        """
+        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system. When
+        the token expires, the user must request a new token.
+        """
+        response = self.get_http_session().post(
+            self.format_url("/token"),
+            json={
+                "username": username,
+                "password": password,
+            },
+        )
+        response.raise_for_status()
+
+        result = deserialize(response.json(), TokenOutput)
+        self.client.add_token(result.access_token)
+
+        return result
+
+    def get_available_permissions(self) -> dict[int | str, Any]:
+        """
+        This endpoint is used to get a list of available permissions in the system. The permissions are used to define
+        the access rights of the users in the system. The permissions are defined by the system administrator.
+        :return array<int|string, Any>, the available permissions
+        """
+        response = self.get_http_client().get(self.format_url("/available-permissions"))
+        response.raise_for_status()
+
+        return response.json()
+
+    def me(self, token: str) -> MeOutput:
+        """
+        This endpoint is used to get the current user information. The user information includes the list of agents
+        the user has access to. This endpoint requires authentication.
+        """
+        self.client.add_token(token)
+
+        response = self.get_http_client().get("/me")
+        response.raise_for_status()
+
+        result = deserialize(response.json(), MeOutput)
+        return result

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/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,14 +22,19 @@ 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)
 
-    def get_http_session(self):
+    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) -> ClientConnection:
-        return await self.client.ws_client.get_client(agent_id, user_id)
+    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,
@@ -56,12 +62,13 @@ class AbstractEndpoint(ABC):
         output_class: Type[T] | None = None,
         payload: Dict[str, Any] | 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:

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/conversation.py

@@ -1,8 +1,12 @@
-from typing import Literal, Dict
+from typing import List
 
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
-from cheshirecat_python_sdk.models.api.conversations import ConversationHistoryOutput, ConversationHistoryDeleteOutput
-from cheshirecat_python_sdk.models.dtos import Why
+from cheshirecat_python_sdk.models.api.conversations import (
+    ConversationHistoryOutput,
+    ConversationDeleteOutput,
+    ConversationsResponse,
+    ConversationNameChangeOutput,
+)
 from cheshirecat_python_sdk.utils import deserialize
 
 
@@ -26,70 +30,54 @@ class ConversationEndpoint(AbstractEndpoint):
             output_class=ConversationHistoryOutput,
         )
 
-    def get_conversation_histories(self, agent_id: str, user_id: str) -> Dict[str, ConversationHistoryOutput]:
+    def get_conversations(self, agent_id: str, user_id: str) -> List[ConversationsResponse]:
         """
-        This endpoint returns the conversation histories.
+        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: ConversationHistoryOutput, a list of conversation history entries.
+        :return: List[ConversationsResponse], a list of conversation attributes.
         """
         response = self.get_http_client(agent_id, user_id).get(self.prefix)
         response.raise_for_status()
 
-        result = {}
-        for key, item in response.json():
-            result[key] = deserialize(item, ConversationHistoryOutput)
-        return result
+        return [deserialize(item, ConversationsResponse) for item in response.json()]
 
-    def delete_conversation_history(self, agent_id: str, user_id: str, chat_id: str) -> ConversationHistoryDeleteOutput:
+    def delete_conversation(self, agent_id: str, user_id: str, chat_id: str) -> ConversationDeleteOutput:
         """
-        This endpoint deletes the conversation history.
+        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: ConversationHistoryDeleteOutput, a message indicating the number of conversation history entries deleted.
+        :return: ConversationDeleteOutput, a message indicating whether the conversation was deleted.
         """
         return self.delete(
             self.format_url(chat_id),
             agent_id,
-            output_class=ConversationHistoryDeleteOutput,
+            output_class=ConversationDeleteOutput,
             user_id=user_id,
         )
 
-    def post_conversation_history(
+    def post_conversation_name(
         self,
-        who: Literal["user", "assistant"],
-        text: str,
+        name: str,
         agent_id: str,
         user_id: str,
         chat_id: str,
-        image: str | bytes | None = None,
-        why: Why | None = None,
-    ) -> ConversationHistoryOutput:
+    ) -> ConversationNameChangeOutput:
         """
         This endpoint creates a new element in the conversation history.
-        :param who: The role of the user in the conversation.
-        :param text: The text of the conversation history entry.
+        :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.
-        :param image: The image of the conversation history entry.
-        :param why: The reason for the conversation history entry.
-        :return: ConversationHistoryOutput, the conversation history entry created.
+        :return: ConversationNameChangeOutput, a message indicating whether the conversation name was changed.
         """
-        payload = {
-            "who": who,
-            "text": text,
-        }
-        if image:
-            payload["image"] = image
-        if why:
-            payload["why"] = why.model_dump()
+        payload = {"name": name}
 
         return self.post_json(
             self.format_url(chat_id),
             agent_id,
-            output_class=ConversationHistoryOutput,
+            output_class=ConversationNameChangeOutput,
             payload=payload,
             user_id=user_id,
         )

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/file_manager.py

@@ -3,7 +3,7 @@ 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
+from cheshirecat_python_sdk.models.api.file_managers import FileManagerAttributes, FileManagerDeletedFiles
 
 
 class FileManagerEndpoint(AbstractEndpoint):
@@ -61,18 +61,43 @@ class FileManagerEndpoint(AbstractEndpoint):
         """
         return self.get(self.prefix, agent_id, output_class=FileManagerAttributes)
 
-    def get_file(self, agent_id: str, file_path: str) -> Response:
+    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_path: The path of the file to download
+        :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"/download/{file_path}"),
+            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-1.7.8/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-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/message.py

@@ -2,25 +2,34 @@ from typing import Callable
 import json
 
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
-from cheshirecat_python_sdk.models.api.messages import MessageOutput
+from cheshirecat_python_sdk.models.api.messages import ChatOutput
 from cheshirecat_python_sdk.models.dtos import Message
 from cheshirecat_python_sdk.utils import deserialize
 
 
 class MessageEndpoint(AbstractEndpoint):
-    def send_http_message(self, message: Message, agent_id: str, user_id: str) -> MessageOutput:
+    def send_http_message(
+        self,
+        message: Message,
+        agent_id: str,
+        user_id: str,
+        chat_id: str | None = None,
+    ) -> ChatOutput:
         """
         This endpoint sends a message to the agent identified by the agentId parameter. The message is sent via HTTP.
         :param message: Message object, the message to send
         :param agent_id: the agent id
         :param user_id: the user id
+        :param chat_id: the chat id (optional)
+        :return: ChatOutput object
         """
         return self.post_json(
             '/message',
             agent_id,
-            output_class=MessageOutput,
+            output_class=ChatOutput,
             payload=message.model_dump(),
             user_id=user_id,
+            chat_id=chat_id,
         )
 
     async def send_websocket_message(
@@ -28,21 +37,24 @@ class MessageEndpoint(AbstractEndpoint):
         message: Message,
         agent_id: str,
         user_id: str,
+        chat_id: str | None = None,
         callback: Callable[[str], None] | None = None
-    ) -> MessageOutput:
+    ) -> ChatOutput:
         """
         This endpoint sends a message to the agent identified by the agentId parameter. The message is sent via WebSocket.
         :param message: Message object, the message to send
         :param agent_id: the agent id
         :param user_id: the user id
+        :param chat_id: the chat id
         :param callback: callable, a callback function that will be called for each message received
+        :return: ChatOutput object
         """
         try:
             json_data = json.dumps(message.model_dump())
         except Exception:
             raise RuntimeError("Error encoding message")
 
-        client = await self.get_ws_client(agent_id, user_id)
+        client = await self.get_ws_client(agent_id, user_id, chat_id)
 
         try:
             await client.send(json_data)
@@ -62,4 +74,4 @@ class MessageEndpoint(AbstractEndpoint):
             raise Exception(f"WebSocket error: {str(e)}")
 
         await client.close()
-        return deserialize(json.loads(response), MessageOutput)
+        return deserialize(json.loads(response), ChatOutput)

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/plugins.py

@@ -74,3 +74,16 @@ class PluginsEndpoint(AbstractEndpoint):
             output_class=PluginSettingsOutput,
             payload=values,
         )
+
+    def post_plugin_reset_settings(self, plugin_id: str, agent_id: str) -> PluginSettingsOutput:
+        """
+        This endpoint resets the plugin settings to the factory values
+        :param plugin_id: The id of the plugin
+        :param agent_id: The id of the agent
+        :return: PluginSettingsOutput, the plugin settings after reset
+        """
+        return self.post_json(
+            self.format_url(f"/settings/{plugin_id}"),
+            agent_id,
+            output_class=PluginSettingsOutput,
+        )

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/rabbit_hole.py

@@ -20,6 +20,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         self,
         file_path,
         agent_id: str,
+        chat_id: str | None = None,
         file_name: str | None = None,
         metadata: Dict[str, Any] | None = None,
     ) -> UploadSingleFileResponse:
@@ -30,6 +31,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         The CheshireCat processes the injection in background and the client will be informed at the end of the process.
         :param file_path: The path to the file to upload.
         :param agent_id: The ID of the agent.
+        :param chat_id: The ID of the chat (optional).
         :param file_name: The name of the file.
         :param metadata: The metadata to include with the file.
         :return: The response from the RabbitHole API.
@@ -40,9 +42,11 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         if metadata is not None:
             payload.data["metadata"] = json.dumps(metadata)
 
+        endpoint = self.prefix if not chat_id else self.format_url(chat_id)
+
         with open(file_path, "rb") as file:
             payload.files = [("file", file_attributes(file_name, file))]
-            result = self.post_multipart(self.prefix, agent_id, output_class=UploadSingleFileResponse, payload=payload)
+            result = self.post_multipart(endpoint, agent_id, output_class=UploadSingleFileResponse, payload=payload)
 
         return result
 
@@ -50,6 +54,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         self,
         file_paths: List[str],
         agent_id: str,
+        chat_id: str | None = None,
         metadata: Dict[str, Any] | None = None
     ) -> Dict[str, UploadSingleFileResponse]:  # type: ignore
         """
@@ -58,6 +63,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         The CheshireCat processes the injection in background and the client will be informed at the end of the process.
         :param file_paths: The paths to the files to upload.
         :param agent_id: The ID of the agent.
+        :param chat_id: The ID of the chat (optional).
         :param metadata: The metadata to include with the files.
         :return: The response from the RabbitHole API.
         """
@@ -67,13 +73,15 @@ class RabbitHoleEndpoint(AbstractEndpoint):
 
         files = []
         file_handles = []
+
+        endpoint = self.format_url("/batch") if not chat_id else self.format_url(f"/batch/{chat_id}")
         try:
             for file_path in file_paths:
                 file = open(file_path, "rb")
                 file_handles.append(file)
                 files.append(("files", file_attributes(Path(file_path).name, file)))
 
-            response = self.get_http_client(agent_id).post(self.format_url("/batch"), data=data, files=files)
+            response = self.get_http_client(agent_id).post(endpoint, data=data, files=files)
             response.raise_for_status()
 
             result = {}
@@ -88,6 +96,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         self,
         web_url: str,
         agent_id: str,
+        chat_id: str | None = None,
         metadata: Dict[str, Any] | None = None
     ) -> UploadUrlResponse:
         """
@@ -97,6 +106,7 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         The CheshireCat processes the injection in background, and the client will be informed at the end of the process.
         :param web_url: The URL of the website to ingest.
         :param agent_id: The ID of the agent.
+        :param chat_id: The ID of the chat (optional).
         :param metadata: The metadata to include with the files.
         :return: The response from the RabbitHole API.
         """
@@ -104,7 +114,9 @@ class RabbitHoleEndpoint(AbstractEndpoint):
         if metadata is not None:
             payload["metadata"] = metadata  # type: ignore
 
-        return self.post_json(self.format_url("/web"), agent_id, output_class=UploadUrlResponse, payload=payload)
+        endpoint = self.format_url("/web") if not chat_id else self.format_url(f"/web/{chat_id}")
+
+        return self.post_json(endpoint, agent_id, output_class=UploadUrlResponse, payload=payload)
 
     def post_memory(
         self,

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/endpoints/users.py

@@ -1,7 +1,6 @@
 from typing import Any, List, Dict
 
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
-from cheshirecat_python_sdk.models.api.tokens import TokenOutput
 from cheshirecat_python_sdk.models.api.users import UserOutput
 from cheshirecat_python_sdk.utils import deserialize
 
@@ -11,33 +10,6 @@ class UsersEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/users"
 
-    def token(self, username: str, password: str) -> TokenOutput:
-        """
-        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system. When
-        the token expires, the user must request a new token.
-        """
-        response = self.get_http_session().post("/auth/token", json={
-            "username": username,
-            "password": password,
-        })
-        response.raise_for_status()
-
-        result = deserialize(response.json(), TokenOutput)
-        self.client.add_token(result.access_token)
-
-        return result
-
-    def get_available_permissions(self) -> dict[int | str, Any]:
-        """
-        This endpoint is used to get a list of available permissions in the system. The permissions are used to define
-        the access rights of the users in the system. The permissions are defined by the system administrator.
-        :return array<int|string, Any>, the available permissions
-        """
-        response = self.get_http_client().get("/auth/available-permissions")
-        response.raise_for_status()
-
-        return response.json()
-
     def post_user(
         self, agent_id: str, username: str, password: str, permissions: dict[str, Any] | None = None
     ) -> UserOutput:

cheshirecat_python_sdk-1.7.8/cheshirecat_python_sdk/endpoints/utils.py

@@ -0,0 +1,71 @@
+from typing import List
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.admins import ResetOutput, ClonedOutput, CreatedOutput
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class UtilsEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/utils"
+
+    def post_factory_reset(self) -> ResetOutput:
+        """
+        Reset the system to the factory settings.
+        :return: ResetOutput, the details of the reset.
+        """
+        return self.post_json(self.format_url("/factory/reset/"), self.system_id, output_class=ResetOutput)
+
+    def get_agents(self) -> List[str]:
+        """
+        Get a list of all agents.
+        :return: List[str], the IDs of the agents.
+        """
+        return self.get(self.format_url("/agents/"), self.system_id)
+
+    def post_agent_create(self, agent_id: str) -> CreatedOutput:
+        """
+        Create a new agent.
+        :param agent_id: The ID of the agent.
+        :return: CreatedOutput, the details of the agent.
+        """
+        response = self.get_http_client().post(
+            self.format_url("/agents/create/"),
+            json={
+                "agent_id": agent_id,
+            },
+        )
+        response.raise_for_status()
+
+        return deserialize(response.json(), CreatedOutput)
+
+    def post_agent_reset(self, agent_id: str) -> ResetOutput:
+        """
+        Reset an agent to the factory settings.
+        :param agent_id: The ID of the agent.
+        :return: ResetOutput, the details of the reset.
+        """
+        return self.post_json(self.format_url("/agents/reset/"), agent_id, output_class=ResetOutput)
+
+    def post_agent_destroy(self, agent_id: str) -> ResetOutput:
+        """
+        Destroy an agent.
+        :param agent_id: The ID of the agent.
+        :return: ResetOutput, the details of the reset.
+        """
+        return self.post_json(self.format_url("/agents/destroy/"), agent_id, output_class=ResetOutput)
+
+    def post_agent_clone(self, agent_id: str, new_agent_id: str) -> ClonedOutput:
+        """
+        Destroy an agent.
+        :param agent_id: The ID of the agent.
+        :param new_agent_id: The ID of the new cloned agent.
+        :return: ClonedOutput, the details of the cloning.
+        """
+        return self.post_json(
+            self.format_url("/agents/clone/"),
+            agent_id,
+            payload={"agent_id": new_agent_id},
+            output_class=ClonedOutput
+        )

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/models/api/admins.py

@@ -36,3 +36,7 @@ class ResetOutput(BaseModel):
     deleted_settings: bool
     deleted_memories: bool
     deleted_plugin_folders: bool
+
+
+class ClonedOutput(BaseModel):
+    cloned: bool = False

cheshirecat_python_sdk-1.7.8/cheshirecat_python_sdk/models/api/conversations.py

@@ -0,0 +1,24 @@
+from typing import List
+from pydantic import BaseModel
+
+from cheshirecat_python_sdk.models.api.nested.memories import ConversationMessage
+
+
+class ConversationDeleteOutput(BaseModel):
+    deleted: bool
+
+
+class ConversationHistoryOutput(BaseModel):
+    history: List[ConversationMessage]
+
+
+class ConversationsResponse(BaseModel):
+    chat_id: str
+    name: str
+    num_messages: int
+    created_at: float | None
+    updated_at: float | None
+
+
+class ConversationNameChangeOutput(BaseModel):
+    changed: bool

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/models/api/file_managers.py

@@ -12,3 +12,7 @@ class FileResponse(BaseModel):
 class FileManagerAttributes(BaseModel):
     files: List[FileResponse]
     size: int
+
+
+class FileManagerDeletedFiles(BaseModel):
+    deleted: bool

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/models/api/messages.py

@@ -1,4 +1,4 @@
-from pydantic import Field
+from pydantic import Field, BaseModel
 
 from cheshirecat_python_sdk.models.dtos import MessageBase, Why
 
@@ -7,8 +7,10 @@ class MessageOutput(MessageBase):
     why: Why | None = Field(default_factory=Why)  # Assuming Why has a no-args constructor
     type: str | None = "chat"  # Default argument
     error: bool | None = False  # Default argument
-    content: str = Field(init=False)  # Field without a default value
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        self.content = self.text
+
+class ChatOutput(BaseModel):
+    agent_id: str
+    user_id: str
+    chat_id: str
+    message: MessageOutput

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/cheshirecat_python_sdk/models/api/nested/memories.py

@@ -13,7 +13,7 @@ class ConversationHistoryItemContent(MessageBase):
     why: Why | None = None
 
 
-class ConversationHistoryItem(BaseModel):
+class ConversationMessage(BaseModel):
     who: str
     when: float
     content: ConversationHistoryItemContent

cheshirecat_python_sdk-1.7.8/cheshirecat_python_sdk/models/api/tokens.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+
+
+class TokenOutput(BaseModel):
+    access_token: str
+    token_type: str | None = "bearer"
+
+
+class User(BaseModel):
+    id: str
+    username: str
+    permissions: dict[str, list[str]]
+
+
+class AgentMatch(BaseModel):
+    agent_id: str
+    agent_name: str
+    agent_description: str | None = None
+    user: User
+
+
+class MeOutput(BaseModel):
+    success : bool
+    agents: list[AgentMatch]
+    auto_selected: bool

{cheshirecat_python_sdk-1.4.0 → cheshirecat_python_sdk-1.7.8}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "cheshirecat-python-sdk"
 description = "Python SDK for the Cloud-ready fork of the Cheshire Cat"
-version = "1.4.0"
+version = "1.7.8"
 requires-python = ">=3.10"
 license = { file = "LICENSE" }
 authors = [
@@ -66,4 +66,4 @@ disable = [
 ]
 
 [tool.pylint.main]
-load-plugins = "pylint_actions, perflint"
+load-plugins = "pylint_actions, perflint"

cheshirecat_python_sdk-1.4.0/cheshirecat_python_sdk/endpoints/health_check.py

@@ -1,12 +0,0 @@
-from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
-
-class HealthCheckEndpoint(AbstractEndpoint):
-    def home(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("/")
-        response.raise_for_status()
-
-        return response.json()

cheshirecat_python_sdk-1.4.0/cheshirecat_python_sdk/models/api/conversations.py

@@ -1,12 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-
-from cheshirecat_python_sdk.models.api.nested.memories import ConversationHistoryItem
-
-
-class ConversationHistoryDeleteOutput(BaseModel):
-    deleted: bool
-
-
-class ConversationHistoryOutput(BaseModel):
-    history: List[ConversationHistoryItem]

cheshirecat_python_sdk-1.4.0/cheshirecat_python_sdk/models/api/tokens.py

@@ -1,6 +0,0 @@
-from pydantic import BaseModel
-
-
-class TokenOutput(BaseModel):
-    access_token: str
-    token_type: str | None = "bearer"