alita-sdk 0.3.283__tar.gz → 0.3.285__tar.gz

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.283
+Version: 0.3.285
 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.283 → alita_sdk-0.3.285}/alita_sdk/runtime/tools/vectorstore_base.py

@@ -587,7 +587,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
 
         try:
             dispatch_custom_event(
-                name="thinking_step",
+                name="thinking_step_update",
                 data={
                     "message": message,
                     "tool_name": tool_name,

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/base_indexer_toolkit.py

@@ -158,15 +158,22 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         if clean_index:
             self._clean_index(collection_suffix)
         #
+        self._log_tool_event(f"Indexing data into collection with suffix '{collection_suffix}'. It can take some time...")
+        self._log_tool_event(f"Loading the documents to index...{kwargs}")
         documents = self._base_loader(**kwargs)
+        self._log_tool_event(f"Base documents were loaded. "
+                             f"Search for possible document duplicates and remove them from the indexing list...")
         documents = self._reduce_duplicates(documents, collection_suffix)
+        self._log_tool_event(f"Duplicates were removed. "
+                             f"Processing documents to collect dependencies and prepare them for indexing...")
         documents = self._extend_data(documents) # update content of not-reduced base document if needed (for sharepoint and similar)
         documents = self._collect_dependencies(documents) # collect dependencies for base documents
+        self._log_tool_event(f"Documents were processed. "
+                             f"Applying chunking tool '{chunking_tool}' if specified and preparing documents for indexing...")
         documents = self._apply_loaders_chunkers(documents, chunking_tool, chunking_config)
         list_documents = list(documents)
         self._clean_metadata(list_documents)
-
-        #
+        self._log_tool_event(f"Documents are ready for indexing. Total documents to index: {len(list_documents)}")
         return self._save_index(list_documents, collection_suffix=collection_suffix, progress_step=progress_step)
     
     def _apply_loaders_chunkers(self, documents: Generator[Document, None, None], chunking_tool: str=None, chunking_config=None) -> Generator[Document, None, None]:

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/figma/api_wrapper.py

@@ -249,7 +249,9 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
     ) -> Generator[Document, None, None]:
         # If both include and exclude are provided, use only include
         if file_keys_include:
+            self._log_tool_event(f"Loading files: {file_keys_include}")
             for file_key in file_keys_include:
+                self._log_tool_event(f"Loading file `{file_key}`")
                 file = self._client.get_file(file_key)
                 if not file:
                     raise ToolException(f"Unexpected error while retrieving file {file_key}. Probably file is under editing. Try again later.")
@@ -265,6 +267,7 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
                 }
                 yield Document(page_content=json.dumps(metadata), metadata=metadata)
         elif project_id:
+            self._log_tool_event(f"Loading project files from project `{project_id}`")
             files = json.loads(self.get_project_files(project_id)).get('files', [])
             for file in files:
                 if file_keys_exclude and file.get('key', '') in file_keys_exclude:
@@ -286,12 +289,14 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
         file_key = document.metadata.get('id', '')
+        self._log_tool_event(f"Loading details (images) for `{file_key}`")
         #
         figma_pages = self._client.get_file(file_key).document.get('children', [])
         node_ids_include = document.metadata.pop('figma_pages_include', [])
         node_ids_exclude = document.metadata.pop('figma_pages_exclude', [])
         node_types_include = [t.lower() for t in document.metadata.pop('figma_nodes_include', [])]
         node_types_exclude = [t.lower() for t in document.metadata.pop('figma_nodes_exclude', [])]
+        self._log_tool_event(f"Included pages: {node_ids_include}. Excluded pages: {node_ids_exclude}.")
         if node_ids_include:
             figma_pages = [node for node in figma_pages if ('id' in node and node['id'].replace(':', '-') in node_ids_include)]
         elif node_ids_exclude:
@@ -310,7 +315,12 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
         ]
 
         images = self._client.get_file_images(file_key, node_ids).images or {}
-        for node_id, image_url in images.items():
+        total_images = len(images)
+        if total_images == 0:
+            logging.info(f"No images found for file {file_key}.")
+            return
+        progress_step = max(1, total_images // 10)
+        for idx, (node_id, image_url) in enumerate(images.items(), 1):
             if not image_url:
                 logging.warning(f"Image URL not found for node_id {node_id} in file {file_key}. Skipping.")
                 continue
@@ -321,17 +331,22 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
                     extension = f".{content_type.split('/')[-1]}" if content_type.startswith('image') else '.txt'
                     page_content = load_content_from_bytes(
                         file_content=response.content,
-                        extension=extension, llm = self.llm)
+                        extension=extension, llm=self.llm)
                     yield Document(
-                                    page_content=page_content,
-                                    metadata={
-                                        'id': file_key,
-                                        'updated_on': document.metadata.get('updated_on', ''),
-                                        'file_key': file_key,
-                                        'node_id': node_id,
-                                        'image_url': image_url
-                                    }
-                                )
+                        page_content=page_content,
+                        metadata={
+                            'id': node_id,
+                            'updated_on': document.metadata.get('updated_on', ''),
+                            'file_key': file_key,
+                            'node_id': node_id,
+                            'image_url': image_url
+                        }
+                    )
+            if idx % progress_step == 0 or idx == total_images:
+                percent = int((idx / total_images) * 100)
+                msg = f"Processed {idx}/{total_images} images ({percent}%) for file {file_key}."
+                logging.info(msg)
+                self._log_tool_event(msg)
 
     def _remove_metadata_keys(self):
         return super()._remove_metadata_keys() + ['figma_pages_include', 'figma_pages_exclude', 'figma_nodes_include', 'figma_nodes_exclude']

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/gitlab/__init__.py

@@ -44,7 +44,7 @@ class AlitaGitlabToolkit(BaseToolkit):
         return create_model(
             name,
             repository=(str, Field(description="GitLab repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaGitlabToolkit.toolkit_max_length})),
-            gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
+            gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
             branch=(str, Field(description="Main branch", default="main")),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default = None,

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/testrail/api_wrapper.py

@@ -1,8 +1,9 @@
 import json
 import logging
-from typing import Dict, List, Optional, Union, Any, Generator
+from typing import Dict, List, Literal, Optional, Union, Any, Generator
 
 import pandas as pd
+from langchain_core.documents import Document
 from langchain_core.tools import ToolException
 from openai import BadRequestError
 from pydantic import SecretStr, create_model, model_validator
@@ -10,11 +11,9 @@ from pydantic.fields import Field, PrivateAttr
 from testrail_api import StatusCodeError, TestRailAPI
 
 from ..chunkers.code.constants import get_file_extension
-from ..elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
-from langchain_core.documents import Document
-
+from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
 from ...runtime.utils.utils import IndexerKeywords
-from ..utils.content_parser import parse_file_content
 
 try:
     from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
@@ -301,7 +300,7 @@ SUPPORTED_KEYS = {
 }
 
 
-class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
+class TestrailAPIWrapper(NonCodeIndexerToolkit):
     url: str
     password: Optional[SecretStr] = None,
     email: Optional[str] = None,
@@ -322,7 +321,7 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
         password = values.get("password")
         email = values.get("email")
         cls._client = TestRailAPI(url, email, password)
-        return values
+        return super().validate_toolkit(values)
 
     def add_cases(self, add_test_cases_data: str):
         """Adds new test cases into Testrail per defined parameters.
@@ -537,6 +536,7 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
                      suite_id: Optional[str] = None,
                      section_id: Optional[int] = None,
                      title_keyword: Optional[str] = None,
+                     chunking_tool: str = None,
                      **kwargs: Any
                      ) -> Generator[Document, None, None]:
         self._include_attachments = kwargs.get('include_attachments', False)
@@ -558,7 +558,7 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
             cases = [case for case in cases if title_keyword.lower() in case.get('title', '').lower()]
 
         for case in cases:
-            yield Document(page_content=json.dumps(case), metadata={
+            metadata = {
                 'project_id': project_id,
                 'title': case.get('title', ''),
                 'suite_id': suite_id or case.get('suite_id', ''),
@@ -572,7 +572,14 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
                 'automation_type': case.get('custom_automation_type') or -1,
                 'section_id': case.get('section_id') or -1,
                 'entity_type': 'test_case',
-            })
+            }
+            if chunking_tool:
+                # content is in metadata for chunking tool post-processing
+                metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = json.dumps(case).encode("utf-8")
+                page_content = ""
+            else:
+                page_content = json.dumps(case)
+            yield Document(page_content=page_content, metadata=metadata)
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
         """
@@ -605,24 +612,23 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
                     continue
 
                 attachment_id = f"attach_{attachment['id']}"
-                # add attachment id to metadata of parent
-                document.metadata.setdefault(IndexerKeywords.DEPENDENT_DOCS.value, []).append(attachment_id)
-                # TODO: pass it to chunkers
-                yield Document(page_content=self._process_attachment(attachment),
+                file_name, content_bytes = self._process_attachment(attachment)
+                yield Document(page_content="",
                                                      metadata={
                                                          'project_id': base_data.get('project_id', ''),
                                                          'id': str(attachment_id),
-                                                         IndexerKeywords.PARENT.value: str(case_id),
                                                          'filename': attachment['filename'],
                                                          'filetype': attachment['filetype'],
                                                          'created_on': attachment['created_on'],
                                                          'entity_type': 'test_case_attachment',
                                                          'is_image': attachment['is_image'],
+                                                         IndexerKeywords.CONTENT_FILE_NAME.value: file_name,
+                                                         IndexerKeywords.CONTENT_IN_BYTES.value: content_bytes
                                                      })
         except json.JSONDecodeError as e:
             raise ToolException(f"Failed to decode JSON from document: {e}")
 
-    def _process_attachment(self, attachment: Dict[str, Any]) -> str:
+    def _process_attachment(self, attachment: Dict[str, Any]) -> tuple[Any, bytes]:
         """
         Processes an attachment to extract its content.
 
@@ -639,12 +645,11 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
         else:
             try:
                 attachment_path = self._client.attachments.get_attachment(attachment_id=attachment['id'], path=f"./{attachment['filename']}")
-                page_content = parse_file_content(file_name=attachment['filename'], file_content=attachment_path.read_bytes(), llm=self.llm, is_capture_image=True)
             except BadRequestError as ai_e:
                 logger.error(f"Unable to parse page's content with type: {attachment['filetype']} due to AI service issues: {ai_e}")
             except Exception as e:
                 logger.error(f"Unable to parse page's content with type: {attachment['filetype']}: {e}")
-        return page_content
+        return (attachment['filename'], attachment_path.read_bytes())
 
     def _index_tool_params(self):
         return {
@@ -658,6 +663,7 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
             'skip_attachment_extensions': (Optional[List[str]], Field(
                 description="List of file extensions to skip when processing attachments: i.e. ['.png', '.jpg']",
                 default=[])),
+            'chunking_tool':(Literal['json'], Field(description="Name of chunking tool", default='json'))
         }
 
     def _to_markup(self, data: List[Dict], output_format: str) -> str:
@@ -687,7 +693,7 @@ class TestrailAPIWrapper(BaseVectorStoreToolApiWrapper):
         if output_format == "markdown":
             return df.to_markdown(index=False)
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         tools = [
             {

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/zephyr_enterprise/__init__.py

@@ -43,7 +43,8 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
                                                                            default=None)),
             # embedder settings
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
-            selected_tools=(List[Literal[tuple(selected_tools)]], []),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Zephyr Enterprise", "icon_url": "zephyr.svg",

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk/tools/zephyr_essential/api_wrapper.py

@@ -179,12 +179,43 @@ class ZephyrEssentialApiWrapper(NonCodeIndexerToolkit):
     def create_folder(self, json: str):
         """Create a new folder."""
         folder_data = self._parse_json(json)
+        if 'parentId' not in folder_data:
+            if 'parentName' in folder_data:
+                parent_folder_name = folder_data['parentName']
+
+                parent_folder = self.find_folder_by_name(parent_folder_name)
+
+                if isinstance(parent_folder, ToolException):
+                    return ToolException(f"Folder with name '{parent_folder_name}' not found.")
+                else:
+                    folder_data['parentId'] = parent_folder['id']
+
         return self._client.create_folder(folder_data)
 
     def get_folder(self, folder_id: str):
         """Retrieve details of a specific folder."""
         return self._client.get_folder(folder_id)
 
+    def find_folder_by_name(self, name: str, project_key: Optional[str] = None, folder_type: Optional[str] = None):
+        """
+        Find a folder by its name, ignoring case.
+
+        :param name: The name of the folder to search for.
+        :param project_key: Optional filter by project key.
+        :param folder_type: Optional filter by folder type.
+        :return: The folder details if found, otherwise None.
+        """
+        # Fetch all folders with optional filters
+        folders = self.list_folders(project_key=project_key, folder_type=folder_type)
+
+        # Iterate through the folders and search for the matching name
+        for folder in folders['values']:
+            if folder.get('name', '').lower() == name.lower():
+                return folder
+
+        # Return None if no folder is found
+        return ToolException(f"Folder with name {name} was not found")
+
     def delete_link(self, link_id: str):
         """Delete a specific link."""
         return self._client.delete_link(link_id)
@@ -482,6 +513,12 @@ class ZephyrEssentialApiWrapper(NonCodeIndexerToolkit):
                 "args_schema": GetFolder,
                 "ref": self.get_folder,
             },
+            {
+                "name": "find_folder_by_name",
+                "description": self.find_folder_by_name.__doc__,
+                "args_schema": FindFolderByName,
+                "ref": self.find_folder_by_name,
+            },
             {
                 "name": "delete_link",
                 "description": self.delete_link.__doc__,
@@ -879,11 +916,12 @@ CreateFolder = create_model(
         JSON body to create a folder. Example:
         {
             "parentId": 123456,
+            "parentName": "parentFolder",
             "name": "ZephyrEssential_test",
             "projectKey": "PRJ",
             "folderType": "TEST_CASE"
         }
-        Possible folder types: "TEST_CASE", "TEST_PLAN", "TEST_CYCLE"
+        Possible folder types: "TEST_CASE", "TEST_PLAN", "TEST_CYCLE",
         """
     )))
 )
@@ -893,6 +931,14 @@ GetFolder = create_model(
     folder_id=(str, Field(description="ID of the folder to retrieve."))
 )
 
+FindFolderByName = create_model(
+    "GetFolder",
+    name=(str, Field(description="Name of the folder to retrieve.")),
+    project_key=(Optional[str], Field(description="Project key", default=None)),
+    folder_type=(Optional[str], Field(description="""Folder type. Possible values: "TEST_CASE", "TEST_PLAN", "TEST_CYCLE" """,
+                                      default=None)),
+)
+
 DeleteLink = create_model(
     "DeleteLink",
     link_id=(str, Field(description="ID of the link to delete."))

{alita_sdk-0.3.283 → alita_sdk-0.3.285}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.283
+Version: 0.3.285
 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.283 → alita_sdk-0.3.285}/pyproject.toml

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