alita-sdk 0.3.261__tar.gz → 0.3.263__tar.gz

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.261
+Version: 0.3.263
 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.261 → alita_sdk-0.3.263}/alita_sdk/runtime/clients/artifact.py

@@ -77,4 +77,11 @@ class Artifact:
         if not bucket_name:
             bucket_name = self.bucket_name
         return self.create(artifact_name, new_data, bucket_name)
+    
+    def get_content_bytes(self,
+            artifact_name: str,
+            bucket_name: str = None):
+        if not bucket_name:
+            bucket_name = self.bucket_name
+        return self.client.download_artifact(bucket_name, artifact_name)
     

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/runtime/clients/client.py

@@ -20,6 +20,7 @@ from .prompt import AlitaPrompt
 from .datasource import AlitaDataSource
 from .artifact import Artifact
 from ..langchain.chat_message_template import Jinja2TemplatedChatMessagesTemplate
+from ..utils.utils import TOOLKIT_SPLITTER
 from ...tools import get_available_toolkit_models
 
 logger = logging.getLogger(__name__)
@@ -762,7 +763,7 @@ class AlitaClient:
                             base_available_tools.append(base_name)
 
                         # Track full names separately
-                        if '___' in tool_name_attr:
+                        if TOOLKIT_SPLITTER in tool_name_attr:
                             full_available_tools.append(tool_name_attr)
 
                 # Create comprehensive error message

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/runtime/toolkits/artifact.py

@@ -3,7 +3,7 @@ from typing import List, Any, Literal, Optional
 from alita_sdk.tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
 from langchain_community.agent_toolkits.base import BaseToolkit
 from langchain_core.tools import BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from pydantic.fields import FieldInfo
 from ..tools.artifact import ArtifactWrapper
 from alita_sdk.tools.base.tool import BaseAction

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/runtime/toolkits/tools.py

@@ -74,11 +74,9 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                 selected_tools=tool['settings'].get('selected_tools', []),
                 llm=llm,
                 # indexer settings
-                connection_string=tool['settings'].get('connection_string', None),
-                collection_name=tool.get('toolkit_name'),
+                pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                 embedding_model=tool['settings'].get('embedding_model'),
-                embedding_model_params=tool['settings'].get('embedding_model_params', None),
-                vectorstore_type="PGVector"
+                collection_name=f"{tool.get('toolkit_name')}",
             ).get_tools())
         elif tool['type'] == 'vectorstore':
             tools.extend(VectorStoreToolkit.get_toolkit(

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/runtime/tools/artifact.py

@@ -1,15 +1,17 @@
 import hashlib
 import json
 import logging
-from typing import Any, Optional, Generator, List
+from typing import Any, Optional, Generator
 
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
 from pydantic import create_model, Field, model_validator
 
-from alita_sdk.tools.elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+from alita_sdk.tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
+from alita_sdk.tools.utils.available_tools_decorator import extend_with_parent_available_tools
 
-class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
+
+class ArtifactWrapper(NonCodeIndexerToolkit):
     bucket: str
     artifact: Optional[Any] = None
     
@@ -21,7 +23,7 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
         if not values.get('bucket'):
             raise ValueError("Bucket is required.")
         values["artifact"] = values['alita'].artifact(values['bucket'])
-        return values
+        return super().validate_toolkit(values)
 
     def list_files(self, bucket_name = None, return_as_string = True):
         return self.artifact.list(bucket_name, return_as_string)
@@ -76,20 +78,18 @@ class ArtifactWrapper(BaseVectorStoreToolApiWrapper):
         hasher.update(file_name.encode('utf-8'))
         return hasher.hexdigest()
 
-    def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        try:
-            page_content = self.read_file(document.metadata['name'], is_capture_image=True, excel_by_sheets=True)
-        except Exception as e:
-            logging.error(f"Failed while parsing the file 'document.metadata['Path']': {e}")
-        if isinstance(page_content, dict):
-            for key, value in page_content.items():
-                metadata = document.metadata
-                metadata['page'] = key
-                yield Document(page_content=str(value), metadata=metadata)
-        else:
-            document.page_content = json.dumps(str(page_content))
-
-    @extend_with_vector_tools
+    def _extend_data(self, documents: Generator[Document, None, None]):
+        for document in documents:
+            try:
+                page_content = self.artifact.get_content_bytes(artifact_name=document.metadata['name'])
+                document.metadata['loader_content'] = page_content
+                document.metadata['loader_content_type'] = document.metadata['name']
+                yield document
+            except Exception as e:
+                logging.error(f"Failed while parsing the file '{document.metadata['name']}': {e}")
+                yield document
+
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         bucket_name = (Optional[str], Field(description="Name of the bucket to work with."
                                                         "If bucket is not specified by user directly, the name should be taken from chat history."

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/runtime/tools/vectorstore_base.py

@@ -421,7 +421,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                         for result in text_results:
                             doc_id = result['id']
                             text_score = result['text_score']
-                            
+
                             if doc_id in doc_map:
                                 # Document exists in vector results, combine scores
                                 doc, vector_score = doc_map[doc_id]
@@ -452,7 +452,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
         
         # Apply cutoff filter
         if cut_off:
-            combined_items = [item for item in combined_items if abs(item[1]) >= cut_off]
+            combined_items = [item for item in combined_items if abs(item[1]) <= cut_off]
         
         # Sort by score and limit results
         # DISABLED: for chroma we want ascending order (lower score is better), for others descending

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/tools/bitbucket/__init__.py

@@ -3,7 +3,6 @@ from typing import Dict, List, Literal, Optional
 from requests.auth import HTTPBasicAuth
 
 from .api_wrapper import BitbucketAPIWrapper
-from .tools import __all__
 from langchain_core.tools import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field, ConfigDict, create_model
@@ -41,10 +40,8 @@ class AlitaBitbucketToolkit(BaseToolkit):
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
-        selected_tools = {}
-        for t in __all__:
-            default = t['tool'].__pydantic_fields__['args_schema'].default
-            selected_tools[t['name']] = default.schema() if default else default
+        selected_tools = {x['name']: x['args_schema'].schema() for x in
+                          BitbucketAPIWrapper.model_construct().get_available_tools()}
         AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
@@ -98,7 +95,7 @@ class AlitaBitbucketToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         bitbucket_api_wrapper = BitbucketAPIWrapper(**wrapper_payload)
-        available_tools: List[Dict] = __all__
+        available_tools: List[Dict] = bitbucket_api_wrapper.get_available_tools()
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
         for tool in available_tools:

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk/tools/bitbucket/api_wrapper.py

@@ -2,21 +2,119 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
+import fnmatch
 
 from langchain_core.tools import ToolException
-from pydantic import model_validator, SecretStr
+from pydantic import model_validator, SecretStr, create_model, Field
 from .bitbucket_constants import create_pr_data
 from .cloud_api_wrapper import BitbucketCloudApi, BitbucketServerApi
 from pydantic.fields import PrivateAttr
 
-from ..elitea_base import BaseCodeToolApiWrapper
+from ..elitea_base import BaseCodeToolApiWrapper, extend_with_vector_tools
 
 logger = logging.getLogger(__name__)
 
+# Pydantic model definitions for tool arguments
+CreateBranchModel = create_model(
+    "CreateBranchModel",
+    branch_name=(str, Field(description="The name of the branch, e.g. `my_branch`.")),
+)
 
-if TYPE_CHECKING:
-    pass
+CreatePullRequestModel = create_model(
+    "CreatePullRequestModel",
+    pr_json_data=(str, Field(description=create_pr_data)),
+)
+
+CreateFileModel = create_model(
+    "CreateFileModel",
+    file_path=(str, Field(description="The path of the file")),
+    file_contents=(str, Field(description="The contents of the file")),
+    branch=(str, Field(description="The branch to create the file in")),
+)
+
+UpdateFileModel = create_model(
+    "UpdateFileModel",
+    file_path=(str, Field(description="The path of the file")),
+    update_query=(str, Field(description="Contains the file contents required to be updated. "
+                                       "The old file contents is wrapped in OLD <<<< and >>>> OLD. "
+                                       "The new file contents is wrapped in NEW <<<< and >>>> NEW")),
+    branch=(str, Field(description="The branch to update the file in")),
+)
+
+ReadFileModel = create_model(
+    "ReadFileModel",
+    file_path=(str, Field(description="The path of the file")),
+    branch=(str, Field(description="The branch to read the file from")),
+)
+
+SetActiveBranchModel = create_model(
+    "SetActiveBranchModel",
+    branch_name=(str, Field(description="The name of the branch, e.g. `my_branch`.")),
+)
+
+ListBranchesInRepoModel = create_model(
+    "ListBranchesInRepoModel",
+    limit=(Optional[int], Field(default=20, description="Maximum number of branches to return. If not provided, all branches will be returned.")),
+    branch_wildcard=(Optional[str], Field(default=None, description="Wildcard pattern to filter branches by name. If not provided, all branches will be returned."))
+)
+
+ListFilesModel = create_model(
+    "ListFilesModel",
+    path=(Optional[str], Field(description="The path to list files from")),
+    recursive=(bool, Field(description="Whether to list files recursively", default=True)),
+    branch=(Optional[str], Field(description="The branch to list files from")),
+)
+
+GetPullRequestsCommitsModel = create_model(
+    "GetPullRequestsCommitsModel",
+    pr_id=(str, Field(description="The ID of the pull request to get commits from")),
+)
+
+GetPullRequestModel = create_model(
+    "GetPullRequestModel",
+    pr_id=(str, Field(description="The ID of the pull request to get details from")),
+)
+
+GetPullRequestsChangesModel = create_model(
+    "GetPullRequestsChangesModel",
+    pr_id=(str, Field(description="The ID of the pull request to get changes from")),
+)
+
+AddPullRequestCommentModel = create_model(
+    "AddPullRequestCommentModel",
+    pr_id=(str, Field(description="The ID of the pull request to add a comment to")),
+    content=(str, Field(description="The comment content")),
+    inline=(Optional[dict], Field(default=None, description="Inline comment details. Example: {'from': 57, 'to': 122, 'path': '<string>'}"))
+)
+
+DeleteFileModel = create_model(
+    "DeleteFileModel",
+    file_path=(str, Field(description="The path of the file")),
+    branch=(str, Field(description="The branch to delete the file from")),
+    commit_message=(str, Field(default=None, description="Commit message for deleting the file. Optional.")),
+)
+
+AppendFileModel = create_model(
+    "AppendFileModel",
+    file_path=(str, Field(description="The path of the file")),
+    content=(str, Field(description="The content to append to the file")),
+    branch=(str, Field(description="The branch to append the file in")),
+)
+
+GetIssuesModel = create_model(
+    "GetIssuesModel",
+)
+
+GetIssueModel = create_model(
+    "GetIssueModel",
+    issue_number=(int, Field(description="The number of the issue")),
+)
+
+CommentOnIssueModel = create_model(
+    "CommentOnIssueModel",
+    comment_query=(str, Field(description="The comment query string")),
+)
 
 
 class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
@@ -41,18 +139,6 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
     """Bitbucket installation type: true for cloud, false for server.
     """
 
-    llm: Optional[Any] = None
-    # Alita instance
-    alita: Optional[Any] = None
-
-    # Vector store configuration
-    connection_string: Optional[SecretStr] = None
-    collection_name: Optional[str] = None
-    doctype: Optional[str] = 'code'
-    embedding_model: Optional[str] = "HuggingFaceEmbeddings"
-    embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
-    vectorstore_type: Optional[str] = "PGVector"
-
     @model_validator(mode='before')
     @classmethod
     def validate_env(cls, values: Dict) -> Dict:
@@ -83,14 +169,34 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
         cls._active_branch = values.get('branch')
         return values
 
-    def set_active_branch(self, branch: str) -> None:
+    def set_active_branch(self, branch_name: str) -> str:
         """Set the active branch for the bot."""
-        self._active_branch = branch
-        return f"Active branch set to `{branch}`"
+        self._active_branch = branch_name
+        return f"Active branch set to `{branch_name}`"
 
-    def list_branches_in_repo(self) -> List[str]:
-        """List all branches in the repository."""
-        return self._bitbucket.list_branches()
+    def list_branches_in_repo(self, limit: Optional[int] = 20, branch_wildcard: Optional[str] = None) -> List[str]:
+        """
+        Lists branches in the repository with optional limit and wildcard filtering.
+
+        Parameters:
+            limit (Optional[int]): Maximum number of branches to return
+            branch_wildcard (Optional[str]): Wildcard pattern to filter branches (e.g., '*dev')
+
+        Returns:
+            List[str]: List containing names of branches
+        """
+        try:
+            branches = self._bitbucket.list_branches()
+
+            if branch_wildcard:
+                branches = [branch for branch in branches if fnmatch.fnmatch(branch, branch_wildcard)]
+
+            if limit is not None:
+                branches = branches[:limit]
+
+            return branches
+        except Exception as e:
+            return f"Failed to list branches: {str(e)}"
 
     def create_branch(self, branch_name: str) -> None:
         """Create a new branch in the repository."""
@@ -266,3 +372,106 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
             return self._bitbucket.get_file(file_path=file_path, branch=branch)
         except Exception as e:
             raise ToolException(f"Can't extract file content (`{file_path}`) due to error:\n{str(e)}")
+
+    def list_files(self, path: str = None, recursive: bool = True, branch: str = None) -> List[str]:
+        """List files in the repository with optional path, recursive search, and branch."""
+        branch = branch if branch else self._active_branch
+        try:
+            files_str = self._get_files(path, branch)
+            # Parse the string response to extract file paths
+            # This is a simplified implementation - might need adjustment based on actual response format
+            import ast
+            try:
+                files_list = ast.literal_eval(files_str)
+                if isinstance(files_list, list):
+                    return files_list
+                else:
+                    return [str(files_list)]
+            except:
+                return [files_str] if files_str else []
+        except Exception as e:
+            return f"Failed to list files: {str(e)}"
+
+    def read_file(self, file_path: str, branch: str) -> str:
+        """Read the contents of a file in the repository."""
+        try:
+            return self._read_file(file_path, branch)
+        except Exception as e:
+            return f"Failed to read file {file_path}: {str(e)}"
+
+    @extend_with_vector_tools
+    def get_available_tools(self):
+        return [
+            {
+                "name": "create_branch",
+                "ref": self.create_branch,
+                "description": self.create_branch.__doc__ or "Create a new branch in the repository.",
+                "args_schema": CreateBranchModel,
+            },
+            {
+                "name": "list_branches_in_repo",
+                "ref": self.list_branches_in_repo,
+                "description": self.list_branches_in_repo.__doc__ or "List branches in the repository with optional limit and wildcard filtering.",
+                "args_schema": ListBranchesInRepoModel,
+            },
+            {
+                "name": "list_files",
+                "ref": self.list_files,
+                "description": self.list_files.__doc__ or "List files in the repository with optional path, recursive search, and branch.",
+                "args_schema": ListFilesModel,
+            },
+            {
+                "name": "create_pull_request",
+                "ref": self.create_pull_request,
+                "description": self.create_pull_request.__doc__ or "Create a pull request in the repository.",
+                "args_schema": CreatePullRequestModel,
+            },
+            {
+                "name": "create_file",
+                "ref": self.create_file,
+                "description": self.create_file.__doc__ or "Create a new file in the repository.",
+                "args_schema": CreateFileModel,
+            },
+            {
+                "name": "read_file",
+                "ref": self.read_file,
+                "description": self.read_file.__doc__ or "Read the contents of a file in the repository.",
+                "args_schema": ReadFileModel,
+            },
+            {
+                "name": "update_file",
+                "ref": self.update_file,
+                "description": self.update_file.__doc__ or "Update the contents of a file in the repository.",
+                "args_schema": UpdateFileModel,
+            },
+            {
+                "name": "set_active_branch",
+                "ref": self.set_active_branch,
+                "description": self.set_active_branch.__doc__ or "Set the active branch in the repository.",
+                "args_schema": SetActiveBranchModel,
+            },
+            {
+                "name": "get_pull_requests_commits",
+                "ref": self.get_pull_requests_commits,
+                "description": self.get_pull_requests_commits.__doc__ or "Get commits from a pull request in the repository.",
+                "args_schema": GetPullRequestsCommitsModel,
+            },
+            {
+                "name": "get_pull_request",
+                "ref": self.get_pull_request,
+                "description": self.get_pull_request.__doc__ or "Get details of a pull request in the repository.",
+                "args_schema": GetPullRequestModel,
+            },
+            {
+                "name": "get_pull_requests_changes",
+                "ref": self.get_pull_requests_changes,
+                "description": self.get_pull_requests_changes.__doc__ or "Get changes from a pull request in the repository.",
+                "args_schema": GetPullRequestsChangesModel,
+            },
+            {
+                "name": "add_pull_request_comment",
+                "ref": self.add_pull_request_comment,
+                "description": self.add_pull_request_comment.__doc__ or "Add a comment to a pull request in the repository.",
+                "args_schema": AddPullRequestCommentModel,
+            },
+        ]

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.261
+Version: 0.3.263
 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.261 → alita_sdk-0.3.263}/alita_sdk.egg-info/SOURCES.txt

@@ -156,7 +156,6 @@ alita_sdk/tools/bitbucket/__init__.py
 alita_sdk/tools/bitbucket/api_wrapper.py
 alita_sdk/tools/bitbucket/bitbucket_constants.py
 alita_sdk/tools/bitbucket/cloud_api_wrapper.py
-alita_sdk/tools/bitbucket/tools.py
 alita_sdk/tools/browser/__init__.py
 alita_sdk/tools/browser/crawler.py
 alita_sdk/tools/browser/duck_duck_go_search.py

{alita_sdk-0.3.261 → alita_sdk-0.3.263}/pyproject.toml

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