alita-sdk 0.3.356__tar.gz → 0.3.357__tar.gz

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.356
+Version: 0.3.357
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/runtime/langchain/document_loaders/AlitaPowerPointLoader.py

@@ -1,10 +1,10 @@
 import io
 
-from langchain_community.document_loaders import UnstructuredPowerPointLoader
 from langchain_core.tools import ToolException
 from pptx import Presentation
 from .utils import perform_llm_prediction_for_image_bytes, create_temp_file
 from pptx.enum.shapes import MSO_SHAPE_TYPE
+from langchain_core.documents import Document
 
 class AlitaPowerPointLoader:
 
@@ -22,16 +22,26 @@ class AlitaPowerPointLoader:
         self.extract_images = unstructured_kwargs.get('extract_images', False)
         self.llm = unstructured_kwargs.get('llm', None)
         self.prompt = unstructured_kwargs.get('prompt', "Describe image")
+        self.pages_per_chunk = unstructured_kwargs.get('pages_per_chunk', 5)
 
     def get_content(self):
-        prs = Presentation(io.BytesIO(self.file_content))
-        text_content = ''
+        if hasattr(self, 'file_path'):
+            with open(self.file_path, 'rb') as f:
+                prs = Presentation(f)
+        elif hasattr(self, 'file_content'):
+            prs = Presentation(io.BytesIO(self.file_content))
+        pages = []
         if self.page_number is not None:
-            text_content += self.read_pptx_slide(prs.slides[self.page_number - 1], self.page_number)
+            pages.append(self.read_pptx_slide(prs.slides[self.page_number - 1], self.page_number))
         else:
             for index, slide in enumerate(prs.slides, start=1):
-                text_content += self.read_pptx_slide(slide, index)
-        return text_content
+                pages.append(self.read_pptx_slide(slide, index))
+        if self.mode == 'single':
+            return "\n".join(pages)
+        if self.mode == 'paged':
+            return pages
+        else:
+            raise ToolException(f"Unknown mode value: {self.mode}. Only 'single', 'paged' values allowed.")
 
     def read_pptx_slide(self, slide, index):
         text_content = f'Slide: {index}\n'
@@ -48,15 +58,34 @@ class AlitaPowerPointLoader:
                 text_content += "\n"
             elif self.extract_images and shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
                 try:
-                    caption = perform_llm_prediction_for_image_bytes(shape.image.blob, self.llm)
+                    caption = perform_llm_prediction_for_image_bytes(shape.image.blob, self.llm, self.prompt)
                 except:
                     caption = "unknown"
                 text_content += "\n**Image Transcript:**\n" + caption + "\n--------------------\n"
         return text_content + "\n"
 
     def load(self):
-        if not self.file_path:
-            self.file_path = create_temp_file(self.file_content)
-        return UnstructuredPowerPointLoader(file_path=self.file_path,
-                           mode=self.mode,
-                           **self.unstructured_kwargs).load()
+        content = self.get_content()
+        if isinstance(content, str):
+            yield Document(page_content=content, metadata={})
+        elif isinstance(content, list):
+            chunk = []
+            chunk_count = 0
+            for page_number, page in enumerate(content, start=1):
+                chunk.append(page)
+                if len(chunk) == self.pages_per_chunk:
+                    chunk_content = "\n".join(chunk)
+                    yield Document(
+                        page_content=chunk_content,
+                        metadata={"chunk_number": chunk_count + 1,
+                                  "pages_in_chunk": list(range(page_number - len(chunk) + 1, page_number + 1))}
+                    )
+                    chunk = []
+                    chunk_count += 1
+            if chunk:
+                chunk_content = "\n".join(chunk)
+                yield Document(
+                    page_content=chunk_content,
+                    metadata={"chunk_number": chunk_count + 1,
+                              "pages_in_chunk": list(range(len(content) - len(chunk) + 1, len(content) + 1))}
+                )

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -288,7 +288,9 @@ document_loaders_map = {
         'allowed_to_override': [
             'max_tokens', 'mode', LoaderProperties.LLM.value,
             LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
+            LoaderProperties.PROMPT_DEFAULT.value,
+            "pages_per_chunk",
+            "extract_images"
         ]
     },
     '.py': {

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -695,6 +695,7 @@ def set_defaults(d):
     type_defaults = {
         'str': '',
         'list': [],
+        'dict': {},
         'int': 0,
         'float': 0.0,
         'bool': False,

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/runtime/langchain/utils.py

@@ -138,7 +138,7 @@ def create_state(data: Optional[dict] = None):
         value = value['type'] if isinstance(value, dict) else value
         if key == 'messages':
             state_dict[key] = Annotated[list[AnyMessage], add_messages]
-        elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number']:
+        elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number', 'dict']:
             state_dict[key] = parse_type(value)
     logger.debug(f"Created state: {state_dict}")
     return TypedDict('State', state_dict)

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/runtime/toolkits/artifact.py

@@ -20,7 +20,15 @@ class ArtifactToolkit(BaseToolkit):
         ArtifactToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             "artifact",
-            bucket = (str, FieldInfo(description="Bucket name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': ArtifactToolkit.toolkit_max_length})),
+            # client = (Any, FieldInfo(description="Client object", required=True, autopopulate=True)),
+            bucket=(str, FieldInfo(
+                description="Bucket name",
+                pattern=r'^[a-z][a-z0-9-]*$',
+                json_schema_extra={
+                    'toolkit_name': True,
+                    'max_toolkit_length': ArtifactToolkit.toolkit_max_length
+                }
+            )),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/tools/figma/api_wrapper.py

@@ -345,7 +345,8 @@ class FigmaApiWrapper(NonCodeIndexerToolkit):
                             text_nodes[node['id']] = self.get_texts_recursive(node)
         # process image nodes
         if image_nodes:
-            images = self._client.get_file_images(file_key, image_nodes).images or {}
+            file_images = self._client.get_file_images(file_key, image_nodes)
+            images = self._client.get_file_images(file_key, image_nodes).images or {} if file_images else {}
             total_images = len(images)
             if total_images == 0:
                 logging.info(f"No images found for file {file_key}.")

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/tools/gitlab/api_wrapper.py

@@ -2,6 +2,8 @@
 from typing import Any, Dict, List, Optional
 import fnmatch
 
+from langchain_core.tools import ToolException
+
 from ..code_indexer_toolkit import CodeIndexerToolkit
 from pydantic import create_model, Field, model_validator, SecretStr, PrivateAttr
 

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/tools/postman/api_wrapper.py

@@ -760,8 +760,9 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 import re
                 def replace_var(match):
                     var_name = match.group(1)
-                    return str(all_variables.get(var_name, match.group(0)))
-                
+                    value = all_variables.get(var_name, match.group(0))
+                    return resolve_variables(value) if isinstance(value, str) else value
+
                 return re.sub(r'\{\{([^}]+)\}\}', replace_var, text)
             
             # Prepare the request

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/tools/qtest/api_wrapper.py

@@ -1,13 +1,13 @@
 import json
 import logging
 from traceback import format_exc
-from typing import Any
+from typing import Any, Optional
 
 import swagger_client
 from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
 from sklearn.feature_extraction.text import strip_tags
-from swagger_client import TestCaseApi, SearchApi, PropertyResource
+from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi
 from swagger_client.rest import ApiException
 
 from ..elitea_base import BaseToolApiWrapper
@@ -99,6 +99,17 @@ DeleteTestCase = create_model(
     qtest_id=(int, Field(description="Qtest id e.g. 3253490123")),
 )
 
+GetModules = create_model(
+    "GetModules",
+    parent_id=(Optional[int],
+               Field(description="ID of the parent Module. Leave it blank to retrieve Modules under root",
+                                    default=None)),
+    search=(Optional[str],
+               Field(description="The free-text to search for Modules by names. You can utilize this parameter to search for Modules. Leave it blank to retrieve all Modules under root or the parent Module",
+                     default=None)),
+
+)
+
 class QtestApiWrapper(BaseToolApiWrapper):
     base_url: str
     qtest_project_id: int
@@ -140,6 +151,9 @@ class QtestApiWrapper(BaseToolApiWrapper):
         # Instantiate the TestCaseApi instance according to the qtest api documentation and swagger client
         return swagger_client.TestCaseApi(self._client)
 
+    def __instantiate_module_api_instance(self) -> ModuleApi:
+        return swagger_client.ModuleApi(self._client)
+
     def __build_body_for_create_test_case(self, test_cases_data: list[dict],
                                           folder_to_place_test_cases_to: str = '') -> list:
         initial_project_properties = self.__get_properties_form_project()
@@ -401,6 +415,20 @@ class QtestApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"""Unable to delete test case in project with id - {self.qtest_project_id} and qtest_id - {qtest_id}. \n Exception: \n {stacktrace}""") from e
 
+    def get_modules(self, parent_id: int = None, search: str = None):
+        """
+        :param int project_id: ID of the project (required)
+        :param int parent_id: ID of the parent Module. Leave it blank to retrieve Modules under root
+        :param str search: The free-text to search for Modules by names. You can utilize this parameter to search for Modules. Leave it blank to retrieve all Modules under root or the parent Module
+        """
+        module_api = self.__instantiate_module_api_instance()
+        kwargs = {}
+        if parent_id:
+            kwargs["parent_id"] = parent_id
+        if search:
+            kwargs["search"] = search
+        return module_api.get_sub_modules_of(project_id=self.qtest_project_id, **kwargs)
+
     def get_available_tools(self):
         return [
             {
@@ -444,5 +472,12 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "description": """Link tests to Jira requirements. The input is jira issue id and th list of test ids in format '["TC-123", "TC-234", "TC-345"]'""",
                 "args_schema": QtestLinkTestCaseToJiraRequirement,
                 "ref": self.link_tests_to_jira_requirement,
+            },
+            {
+                "name": "get_modules",
+                "mode": "get_modules",
+                "description": self.get_modules.__doc__,
+                "args_schema": GetModules,
+                "ref": self.get_modules,
             }
         ]

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk/tools/utils/content_parser.py

@@ -270,7 +270,7 @@ def process_content_by_type(content, filename: str, llm=None, chunking_config=No
                 loader_kwargs.pop(LoaderProperties.PROMPT_DEFAULT.value)
                 loader_kwargs[LoaderProperties.PROMPT.value] = image_processing_prompt
             loader = loader_cls(file_path=temp_file_path, **loader_kwargs)
-            return loader.load()
+            yield from loader.load()
     finally:
         if temp_file_path and os.path.exists(temp_file_path):
             os.remove(temp_file_path)

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.356
+Version: 0.3.357
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.356 → alita_sdk-0.3.357}/pyproject.toml

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