alita-sdk 0.3.209__py3-none-any.whl → 0.3.210__py3-none-any.whl

alita_sdk/tools/utils/content_parser.py

@@ -61,7 +61,7 @@ IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp', 'svg']
 
 
 def parse_file_content(file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
-                       sheet_name: str = None, llm=None, file_path: str = None):
+                       sheet_name: str = None, llm=None, file_path: str = None, excel_by_sheets: bool = False):
     """Parse the content of a file based on its type and return the parsed content.
 
     Args:
@@ -91,7 +91,7 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
     elif file_name.endswith('.docx'):
         return read_docx_from_bytes(file_content)
     elif file_name.endswith('.xlsx') or file_name.endswith('.xls'):
-        return parse_excel(file_content, sheet_name)
+        return parse_excel(file_content, sheet_name, excel_by_sheets)
     elif file_name.endswith('.pdf'):
         return parse_pdf(file_content, page_number, is_capture_image, llm)
     elif file_name.endswith('.pptx'):
@@ -109,17 +109,26 @@ def parse_txt(file_content):
     except Exception as e:
         return ToolException(f"Error decoding file content: {e}")
 
-def parse_excel(file_content, sheet_name = None):
+def parse_excel(file_content, sheet_name = None, return_by_sheets: bool = False):
     try:
         excel_file = io.BytesIO(file_content)
         if sheet_name:
             return parse_sheet(excel_file, sheet_name)
         dfs = pd.read_excel(excel_file, sheet_name=sheet_name)
-        result = []
-        for sheet_name, df in dfs.items():
-            df.fillna('', inplace=True)
-            result.append(f"=== Sheet: {sheet_name} ===\n{df.to_string(index=False)}")
-        return "\n\n".join(result)
+
+        if return_by_sheets:
+            result = {}
+            for sheet_name, df in dfs.items():
+                df.fillna('', inplace=True)
+                result[sheet_name] = df.to_dict(orient='records')
+            return result
+        else:
+            result = []
+            for sheet_name, df in dfs.items():
+                df.fillna('', inplace=True)
+                string_content = df.to_string(index=False)
+                result.append(f"====== Sheet name: {sheet_name} ======\n{string_content}")
+            return "\n\n".join(result)
     except Exception as e:
         return ToolException(f"Error reading Excel file: {e}")
 
@@ -194,6 +203,8 @@ def describe_image(image):
     return "\n[Picture: " + processor.decode(out[0], skip_special_tokens=True) + "]\n"
 
 def __perform_llm_prediction_for_image(llm, image: bytes, image_format='png', prompt=image_processing_prompt) -> str:
+    if not llm:
+        raise ToolException("LLM is not provided for image processing.")
     base64_string = bytes_to_base64(image)
     result = llm.invoke([
         HumanMessage(
@@ -207,6 +218,59 @@ def __perform_llm_prediction_for_image(llm, image: bytes, image_format='png', pr
     ])
     return f"\n[Image description: {result.content}]\n"
 
+# TODO: review usage of this function alongside with functions above
+def load_content(file_path: str, extension: str = None, loader_extra_config: dict = None, llm = None) -> str:
+    """
+    Loads the content of a file based on its extension using a configured loader.
+    """
+    try:
+        from ...runtime.langchain.document_loaders.constants import loaders_map
+
+        if not extension:
+            extension = file_path.split('.')[-1].lower()
+
+        loader_config = loaders_map.get(extension)
+        if not loader_config:
+            logger.warning(f"No loader found for file extension: {extension}. File: {file_path}")
+            return ""
+
+        loader_cls = loader_config['class']
+        loader_kwargs = loader_config['kwargs']
+
+        if loader_extra_config:
+            loader_kwargs.update(loader_extra_config)
+        if loader_config['is_multimodal_processing'] and llm:
+            loader_kwargs.update({'llm': llm})
+
+        loader = loader_cls(file_path, **loader_kwargs)
+        documents = loader.load()
+
+        page_contents = [doc.page_content for doc in documents]
+        return "\n".join(page_contents)
+    except Exception as e:
+        error_message = f"Error loading attachment: {str(e)}"
+        logger.warning(f"{error_message} for file {file_path}")
+        return ""
+
+def load_content_from_bytes(file_content: bytes, extension: str = None, loader_extra_config: dict = None, llm = None) -> str:
+    """Loads the content of a file from bytes based on its extension using a configured loader."""
+
+    import tempfile
+
+    # Automatic cleanup with context manager
+    with tempfile.NamedTemporaryFile(mode='w+b', delete=True) as temp_file:
+        # Write data to temp file
+        temp_file.write(file_content)
+        temp_file.flush()  # Ensure data is written
+
+        # Get the file path for operations
+        temp_path = temp_file.name
+
+        # Perform your operations
+        return load_content(temp_path, extension, loader_extra_config, llm)
+
+
+
 def file_to_bytes(filepath):
     """
     Reads a file and returns its content as a bytes object.

alita_sdk/tools/xray/__init__.py

@@ -20,7 +20,14 @@ def get_tools(tool):
         client_secret=tool['settings'].get('client_secret', None),
         limit=tool['settings'].get('limit', 20),
         verify_ssl=tool['settings'].get('verify_ssl', True),
-        toolkit_name=tool.get('toolkit_name')
+        toolkit_name=tool.get('toolkit_name'),
+
+        # indexer settings
+        connection_string=tool['settings'].get('connection_string', None),
+        collection_name=f"{tool.get('toolkit_name')}_{str(tool['id'])}",
+        embedding_model="HuggingFaceEmbeddings",
+        embedding_model_params={"model_name": "sentence-transformers/all-MiniLM-L6-v2"},
+        vectorstore_type="PGVector"
     ).get_tools()