alita-sdk 0.3.200__tar.gz → 0.3.202__tar.gz

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.200
+Version: 0.3.202
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/alita_sdk/tools/ado/repos/__init__.py

@@ -55,7 +55,6 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             project=(str, Field(title="Project", description="ADO project", json_schema_extra={'configuration': True})),
             repository_id=(str, Field(title="Repository ID", description="ADO repository ID",
                                                 json_schema_extra={
-                                                    'toolkit_name': True,
                                                     'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length,
                                                     'configuration': True})),
             token=(SecretStr, Field(title="Token", description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/alita_sdk/tools/postman/api_wrapper.py

@@ -1283,7 +1283,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             self.analyzer.remove_item_ids(collection_data.get("item", []))
 
             response = self._make_request(
-                'POST', '/collections', json={"collection": collection_data})
+                'POST', f'/collections?workspace={self.workspace_id}', json={"collection": collection_data})
             return json.dumps(response, indent=2)
         except Exception as e:
             stacktrace = format_exc()

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/alita_sdk/tools/slack/__init__.py

@@ -25,6 +25,7 @@ def get_tools(tool):
 
 class SlackToolkit(BaseToolkit):
     tools: List[BaseTool] = []
+    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
@@ -52,7 +53,7 @@ class SlackToolkit(BaseToolkit):
                                                                              'configuration_title': True})),
              slack_token=(SecretStr, Field(description="Slack Token like XOXB-*****-*****-*****-*****",
                                            json_schema_extra={'secret': True, 'configuration': True})),
-             channel_id=(str, Field(description="Channel ID", json_schema_extra={'configuration': True})),
+             channel_id=(Optional[str], Field(default=None, description="Channel ID", json_schema_extra={'configuration': True})),
              selected_tools=(List[Literal[tuple(selected_tools)]],
                              Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
              __config__={'json_schema_extra': {'metadata': {"label": "Slack", "icon_url": "slack-icon.svg"}}}
@@ -74,7 +75,7 @@ class SlackToolkit(BaseToolkit):
             tools.append(BaseAction(                
                 api_wrapper=slack_api_wrapper,
                 name=prefix + tool["name"],
-                description=tool["description"],
+                description=f"Slack Tool: {tool['description']}",
                 args_schema=tool["args_schema"],
             ))
         return cls(tools=tools)

alita_sdk-0.3.202/alita_sdk/tools/slack/api_wrapper.py

@@ -0,0 +1,301 @@
+import logging
+from typing import Optional
+from pydantic import BaseModel, Field, SecretStr, create_model, model_validator
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+
+from alita_sdk.tools.elitea_base import BaseToolApiWrapper
+
+
+logger = logging.getLogger(__name__)
+
+SendMessageModel = create_model(
+                    "SendMessageModel",
+                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to send the message to. (like C12345678 for public channels, D12345678 for DMs)")),                   
+                    message=(str, Field(description="The message text to send."))
+                    )
+
+ReadMessagesModel = create_model(
+                    "ReadMessagesModel",
+                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)")),                    
+                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10)."))
+                    )
+
+CreateChannelModel = create_model(
+                    "CreateChannelModel",                     
+                    channel_name=(str, Field(description="Channel ID, user ID, or conversation ID to send the message to. (like C12345678 for public channels, D12345678 for DMs)")),
+                    is_private=(bool, Field(default=False, description="Whether to make the channel private (default: False)."))
+                    )
+
+ListChannelUsersModel = create_model(
+                    "ListChannelUsersModel",
+                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)"))                 
+                    )
+
+ListWorkspaceUsersModel = create_model(
+                    "ListWorkspaceUsersModel"                 
+                    )
+
+ListWorkspaceConversationsModel = create_model(
+                    "ListWorkspaceConversationsModel"                 
+                    )
+
+InviteToConversationModel = create_model(
+                    "InviteToConversationModel" ,
+                    channel_id=(Optional[str], Field(default=None,description="Conversation ID of the channel.")),
+                    user_ids=(list[str], Field(description="List of user IDs to invite."))                  
+                    )
+
+
+
+class SlackApiWrapper(BaseToolApiWrapper):
+
+    """
+    Slack API wrapper for interacting with Slack channels and messages.
+    """
+    slack_token: Optional[SecretStr] = Field(default=None,description="Slack Bot/User OAuth Token like XOXB-*****-*****-*****-*****")
+    channel_id: Optional[str] = Field(default=None, description="Channel ID, user ID, or conversation ID to send the message to. (like C12345678 for public channels, D12345678 for DMs)")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_toolkit(cls, values):
+        token = values.get("slack_token")
+        if not token:
+            logger.error("Slack token is required for authentication.")
+            raise ValueError("Slack token is required for authentication.")
+        return values
+
+    
+    def _get_client(self):
+        if not hasattr(self, "_client") or self._client is None:
+            self._client = WebClient(token=self.slack_token.get_secret_value())
+        return self._client
+    
+    def send_message(self, message: str, channel_id: Optional[str] = None):
+        """
+        Sends a message to a specified Slack channel, user, or conversation.
+        Uses the provided channel_id if given, otherwise falls back to the instance's channel_id.
+        """
+        
+        try:
+
+            client = self._get_client()
+            
+            # Use the passed channel_id if provided, else use self.channel_id
+            channel = channel_id if channel_id else self.channel_id
+            response = client.chat_postMessage(channel=channel, text=message)
+            logger.info(f"Message sent to {channel}: {message}")
+            return f"Message sent successfully to {channel}."
+        
+        except SlackApiError as e:
+            logger.error(f"Failed to send message to {channel}: {e.response['error']}")
+            return f"Received the error :  {e.response['error']}"
+
+    def read_messages(self, limit=10, channel_id: Optional[str] = None):
+        """
+        Reads the latest messages from a Slack channel or conversation.
+       
+        :param limit: int: The number of messages to fetch (default is 10)
+        :return: list: Returns a list of messages with metadata.
+        """
+        try:
+
+            client = self._get_client()
+            logger.info(f"auth test: {client.auth_test()}")
+            # Use the passed channel_id if provided, else use self.channel_id
+            channel = channel_id if channel_id else self.channel_id
+            # Fetch conversation history
+            response = client.conversations_history(
+                channel=channel,
+                limit=limit )
+            
+            # Extract messages from the response
+            messages = self.extract_slack_messages(response.get('messages', []))
+            
+            return messages
+            
+        except SlackApiError as e:
+            # Handle errors from the Slack API
+            logger.error(f"Failed to read message from {channel}: {e.response['error']}")
+            return f"Received the error :  {e.response['error']}"
+        
+    def create_slack_channel(self,  channel_name: str, is_private=False):
+        """
+        Creates a new Slack channel.
+
+        :param channel_name: str: Desired name for the channel (e.g., "my-new-channel").
+        :param is_private: bool: Whether to make the channel private (default: False).
+        :return: dict: Slack API response or error message.
+        """
+
+        try:
+            client = self._get_client()
+            response = client.conversations_create(
+                name=channel_name,
+                is_private=is_private
+            )
+            channel_id = response["channel"]["id"]
+            print(f"Channel '{channel_name}' created successfully! Channel ID: {channel_id}")
+            return {"success": True, "channel_id": channel_id}
+        except SlackApiError as e:
+            error_message = e.response.get("error", "unknown_error")
+            print(f"Failed to create channel '{channel_name}': {error_message}")
+            return {"success": False, "error": error_message}
+    
+
+
+    def list_channel_users(self, channel_id: Optional[str] = None):
+        """
+        Lists all users in the specified Slack channel.
+
+        :param channel_id: Optional[str]: The channel ID to list users from. If not provided, uses self.channel_id.
+        :return: list: List of user dictionaries with their IDs and names.
+        """
+        try:
+            client = self._get_client()
+            # Use the passed channel_id if provided, else use self.channel_id
+            channel = channel_id if channel_id else self.channel_id
+            logger.info
+            if not channel:
+                logger.error("No channel_id provided to list_channel_users.")
+                return "Error: channel_id must be provided either as an argument or set on the instance."
+
+            # Get user IDs in the channel
+            members_response = client.conversations_members(channel=channel)
+            user_ids = members_response.get("members", [])
+
+            # Fetch user info for each user ID
+            users = []
+            for user_id in user_ids:
+                user_info = client.users_info(user=user_id)
+                user = user_info.get("user", {})
+                users.append({"id": user.get("id"), "name": user.get("name")})
+
+            return users
+
+        except SlackApiError as e:
+            logger.error(f"Failed to list users in channel {channel}: {e.response['error']}")
+            return f"Received the error :  {e.response['error']}"
+
+    def list_workspace_users(self):
+        """
+        Fetches and returns a list of all users in the Slack workspace with selected user details.
+
+        :return: list: List of user dictionaries containing id, name, is_bot, email, and team.
+        """
+        try:
+            client = self._get_client()
+            response = client.users_list()  # Fetch users
+            members = self.extract_required_user_fields(response.get('members', []))
+            print(f"Found {len(members)} users.")
+            return members  # Return the list of users
+        except SlackApiError as e:
+            print(f"Error fetching users: {e.response['error']}")
+            return []
+    
+    def list_workspace_conversations(self):
+        """
+        Retrieves and returns a list of all conversations (channels, groups, and direct messages) in the Slack workspace.
+
+        :return: list: List of conversation/channel dictionaries as returned by the Slack API.
+        """
+        try:
+            client = self._get_client()
+            response = client.conversations_list()  # Fetch conversations
+            channels = response.get("channels", [])
+            print(f"Found {len(channels)} channels.")
+            return channels  # Return the list of channels
+        except SlackApiError as e:
+            print(f"Error fetching conversations: {e.response['error']}")
+            return [] 
+
+    def invite_to_conversation(self, user_ids: list, channel_id: Optional[str] = None ):
+        """
+        Invite one or more users to a Slack channel.
+        :param client: Slack WebClient instance.
+        :param channel_id: Conversation ID of the channel.
+        :param user_ids: List of user IDs to invite.
+        """
+        try:
+            client = self._get_client()
+            # Use the passed channel_id if provided, else use self.channel_id
+            channel = channel_id if channel_id else self.channel_id
+            response = client.conversations_invite(channel=channel, users=",".join(user_ids))
+            print(f"Successfully invited users to {channel}.")
+            return response
+        except SlackApiError as e:
+            print(f"Error inviting users: {e.response['error']}")
+            return None
+                
+    def extract_slack_messages(self, data):
+        extracted_info = []
+
+        for item in data:
+            # Extract 'user' and 'text'
+            user = item.get("user", "Undefined User")
+            message = item.get("text", "No message")
+
+            # Extract 'app name'
+            app_name = item.get("bot_profile", {}).get("name", "No App Name")
+            
+            # Append to result
+            extracted_info.append({"user": user, "message": message, "app_name": app_name})
+        
+        return extracted_info
+
+    # Function to extract required user details
+    def extract_required_user_fields(self, user_details):
+        extracted_user_data = []
+        for entry in user_details:
+            extracted_entry = {
+                "id": entry.get("id", None),
+                "name": entry.get("name", None),
+                "is_bot": entry.get("is_bot", None),
+                "email": entry.get("profile", {}).get("email", None),
+                "team": entry.get("profile", {}).get("team", None)
+            }
+            extracted_user_data.append(extracted_entry)
+        return extracted_user_data   
+    
+    def get_available_tools(self):
+        return [
+            {
+                "name": "send_message",
+                "description": self.send_message.__doc__ or "Send a message to a Slack channel, user, or conversation.",
+                "args_schema": SendMessageModel,
+                "ref": self.send_message
+                
+            },
+            {
+                "name": "read_messages",
+                "description": self.read_messages.__doc__ or "Read a message from a Slack channel, user, or conversation.",
+                "args_schema": ReadMessagesModel,
+                "ref": self.read_messages
+            },
+            {
+                "name": "create_slack_channel",
+                "description": self.create_slack_channel.__doc__ or "Create a  Slack channel",
+                "args_schema": CreateChannelModel,
+                "ref": self.create_slack_channel             
+            },
+            {
+                "name": "list_channel_users",
+                "description": self.list_channel_users.__doc__ or "List all users in the Slack channel.",
+                "args_schema": ListChannelUsersModel,
+                "ref": self.list_channel_users
+            },
+            {
+                "name": "list_workspace_users",
+                "description": self.list_workspace_users.__doc__ or "List all users in the Slack workspace.",
+                "args_schema": ListWorkspaceUsersModel,
+                "ref": self.list_workspace_users
+            }
+            ,
+            {
+                "name": "invite_to_conversation",
+                "description": self.invite_to_conversation.__doc__ or "Invite to a conversation in the Slack workspace.",
+                "args_schema": InviteToConversationModel,
+                "ref": self.invite_to_conversation
+            }
+            
+        ]

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.200
+Version: 0.3.202
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.200 → alita_sdk-0.3.202}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.200"
+version = "0.3.202"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"

alita_sdk-0.3.200/alita_sdk/tools/slack/api_wrapper.py

@@ -1,183 +0,0 @@
-import logging
-from typing import Optional
-from pydantic import BaseModel, Field, SecretStr, create_model, model_validator
-from slack_sdk import WebClient
-from slack_sdk.errors import SlackApiError
-
-from alita_sdk.tools.elitea_base import BaseToolApiWrapper
-
-
-logger = logging.getLogger(__name__)
-
-SendMessageModel = create_model(
-                    "SendMessageModel",                    
-                    message=(str, Field(description="The message text to send."))
-                    )
-
-ReadMessagesModel = create_model(
-                    "ReadMessagesModel",                    
-                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10)."))
-                    )
-
-CreateChannelModel = create_model(
-                    "CreateChannelModel",                     
-                    channel_name=(str, Field(description="Channel ID, user ID, or conversation ID to send the message to. (like C12345678 for public channels, D12345678 for DMs)")),
-                    is_private=(bool, Field(default=False, description="Whether to make the channel private (default: False)."))
-                    )
-
-ListUsersModel = create_model(
-                    "ListUsersModel"                 
-                    )
-
-
-class SlackApiWrapper(BaseToolApiWrapper):
-
-    """
-    Slack API wrapper for interacting with Slack channels and messages.
-    """
-    slack_token: Optional[SecretStr] = Field(default=None,description="Slack Bot/User OAuth Token like XOXB-*****-*****-*****-*****")
-    channel_id: Optional[str] = Field(default=None, description="Channel ID, user ID, or conversation ID to send the message to. (like C12345678 for public channels, D12345678 for DMs)")
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_toolkit(cls, values):
-        token = values.get("slack_token")
-        if not token:
-            logger.error("Slack token is required for authentication.")
-            raise ValueError("Slack token is required for authentication.")
-        return values
-    def _get_client(self):
-        if not hasattr(self, "_client") or self._client is None:
-            self._client = WebClient(token=self.slack_token.get_secret_value())
-        return self._client
-    
-    def send_message(self, message: str):
-        """
-        Sends a message to a specified Slack channel, user, or conversation.
-        """
-        
-        try:
-
-            client = self._get_client()
-            response = client.chat_postMessage(channel=self.channel_id, text=message)
-            logger.info(f"Message sent to {self.channel_id}: {message}")
-            return f"Message sent successfully to {self.channel_id}."
-        
-        except SlackApiError as e:
-            logger.error(f"Failed to send message to {self.channel_id}: {e.response['error']}")
-            return f"Received the error :  {e.response['error']}"
-
-    def read_messages(self, limit=10):
-        """
-        Reads the latest messages from a Slack channel or conversation.
-       
-        :param limit: int: The number of messages to fetch (default is 10)
-        :return: list: Returns a list of messages with metadata.
-        """
-        try:
-
-            client = self._get_client()
-            logger.info(f"auth test: {client.auth_test()}")
-            # Fetch conversation history
-            response = client.conversations_history(
-                channel=self.channel_id,
-                limit=limit )
-            
-            # Extract messages from the response
-            messages = self.extract_slack_messages(response.get('messages', []))
-            
-            return messages
-            
-        except SlackApiError as e:
-            # Handle errors from the Slack API
-            logger.error(f"Failed to read message from {self.channel_id}: {e.response['error']}")
-            return f"Received the error :  {e.response['error']}"
-        
-    def create_slack_channel(self,  channel_name: str, is_private=False):
-        """
-        Creates a new Slack channel.
-
-        :param channel_name: str: Desired name for the channel (e.g., "my-new-channel").
-        :param is_private: bool: Whether to make the channel private (default: False).
-        :return: dict: Slack API response or error message.
-        """
-
-        try:
-            client = self._get_client()
-            response = client.conversations_create(
-                name=channel_name,
-                is_private=is_private
-            )
-            channel_id = response["channel"]["id"]
-            print(f"Channel '{channel_name}' created successfully! Channel ID: {channel_id}")
-            return {"success": True, "channel_id": channel_id}
-        except SlackApiError as e:
-            error_message = e.response.get("error", "unknown_error")
-            print(f"Failed to create channel '{channel_name}': {error_message}")
-            return {"success": False, "error": error_message}
-    
-    def list_users(self):
-        """
-        Lists all users in the Slack workspace.
-
-        :return: list: List of users with their IDs and names.
-        """
-        
-        
-        try:
-            client = self._get_client()
-            print(client.auth_test())
-            response = client.users_list()
-            users = response["members"]
-            return [{"id": user["id"], "name": user["name"]} for user in users if not user["is_bot"]]
-        
-        except SlackApiError as e:
-            logger.error(f"Failed to list users: {e.response['error']}")
-            return f"Received the error :  {e.response['error']}"
-    
-    def extract_slack_messages(self, data):
-        extracted_info = []
-
-        for item in data:
-            # Extract 'user' and 'text'
-            user = item.get("user", "Undefined User")
-            message = item.get("text", "No message")
-
-            # Extract 'app name'
-            app_name = item.get("bot_profile", {}).get("name", "No App Name")
-            
-            # Append to result
-            extracted_info.append({"user": user, "message": message, "app_name": app_name})
-        
-        return extracted_info
-    
-    
-    def get_available_tools(self):
-        return [
-            {
-                "name": "send_message",
-                "description": self.send_message.__doc__ or "Send a message to a Slack channel, user, or conversation.",
-                "args_schema": SendMessageModel,
-                "ref": self.send_message
-                
-            },
-            {
-                "name": "read_messages",
-                "description": self.read_messages.__doc__ or "Send a message to a Slack channel, user, or conversation.",
-                "args_schema": ReadMessagesModel,
-                "ref": self.read_messages
-            },
-            {
-                "name": "create_channel",
-                "description": self.create_slack_channel.__doc__ or "Send a message to a Slack channel, user, or conversation.",
-                "args_schema": CreateChannelModel,
-                "ref": self.create_slack_channel             
-            },
-            {
-                "name": "list_users",
-                "description": self.list_users.__doc__ or "List all users in the Slack workspace.",
-                "args_schema": ListUsersModel,
-                "ref": self.list_users
-            }
-            
-        ]