alita-sdk 0.3.347__tar.gz → 0.3.348rc1__tar.gz

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.347
+Version: 0.3.348rc1
 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
@@ -128,6 +128,7 @@ Requires-Dist: textract-py3==2.1.1; extra == "tools"
 Requires-Dist: slack_sdk==3.35.0; extra == "tools"
 Requires-Dist: deltalake==1.0.2; extra == "tools"
 Requires-Dist: google_cloud_bigquery==3.34.0; extra == "tools"
+Requires-Dist: python-calamine==0.5.3; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: pyobjtojson==0.3; extra == "community"

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/clients/artifact.py

@@ -42,7 +42,17 @@ class Artifact:
             return f"{data['error']}. {data['content'] if data['content'] else ''}"
         detected = chardet.detect(data)
         if detected['encoding'] is not None:
-            return data.decode(detected['encoding'])
+            try:
+                return data.decode(detected['encoding'])
+            except Exception:
+                logger.error("Error while default encoding")
+                return parse_file_content(file_name=artifact_name,
+                                          file_content=data,
+                                          is_capture_image=is_capture_image,
+                                          page_number=page_number,
+                                          sheet_name=sheet_name,
+                                          excel_by_sheets=excel_by_sheets,
+                                          llm=llm)
         else:
             return parse_file_content(file_name=artifact_name,
                                   file_content=data,

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/clients/client.py

@@ -69,6 +69,7 @@ class AlitaClient:
         self.configurations_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=configurations&unsecret=true'
         self.ai_section_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=ai'
         self.configurations: list = configurations or []
+        self.model_timeout = kwargs.get('model_timeout', 120)
 
     def get_mcp_toolkits(self):
         if user_id := self._get_real_user_id():
@@ -184,6 +185,7 @@ class AlitaClient:
             model=embedding_model,
             api_key=self.auth_token,
             openai_organization=str(self.project_id),
+            request_timeout=self.model_timeout
         )
 
     def get_llm(self, model_name: str, model_config: dict) -> ChatOpenAI:

alita_sdk-0.3.348rc1/alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py

@@ -0,0 +1,222 @@
+# Copyright (c) 2023 Artem Rozumenko
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import io
+import os
+from typing import Iterator
+import pandas as pd
+from json import loads
+
+from openpyxl import load_workbook
+from xlrd import open_workbook
+from langchain_core.documents import Document
+from .AlitaTableLoader import AlitaTableLoader
+
+cell_delimiter = " | "
+
+class AlitaExcelLoader(AlitaTableLoader):
+    excel_by_sheets: bool = False
+    sheet_name: str = None
+    return_type: str = 'str'
+    file_name: str = None
+
+    def __init__(self, **kwargs):
+        if not kwargs.get('file_path'):
+            file_content = kwargs.get('file_content')
+            if file_content:
+                self.file_name = kwargs.get('file_name')
+                kwargs['file_path'] = io.BytesIO(file_content)
+        else:
+            self.file_name = kwargs.get('file_path')
+        super().__init__(**kwargs)
+        self.excel_by_sheets = kwargs.get('excel_by_sheets')
+        self.return_type = kwargs.get('return_type')
+        self.sheet_name = kwargs.get('sheet_name')
+
+    def get_content(self):
+        try:
+            # Determine file extension
+            file_extension = os.path.splitext(self.file_name)[-1].lower()
+
+            if file_extension == '.xlsx':
+                # Use openpyxl for .xlsx files
+                return self._read_xlsx()
+            elif file_extension == '.xls':
+                # Use xlrd for .xls files
+                return self._read_xls()
+            else:
+                raise ValueError(f"Unsupported file format: {file_extension}")
+        except Exception as e:
+            return f"Error reading Excel file: {e}"
+
+    def _read_xlsx(self):
+        """
+        Reads .xlsx files using openpyxl.
+        """
+        workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
+
+        if self.sheet_name:
+            # If a specific sheet name is provided, parse only that sheet
+            if self.sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[self.sheet_name])
+                return sheet_content
+            else:
+                raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
+        elif self.excel_by_sheets:
+            # Parse each sheet individually and return as a dictionary
+            result = {}
+            for sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[sheet_name])
+                result[sheet_name] = sheet_content
+            return result
+        else:
+            # Combine all sheets into a single string result
+            result = []
+            for sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[sheet_name])
+                result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
+            return "\n\n".join(result)
+
+    def _read_xls(self):
+        """
+        Reads .xls files using xlrd.
+        """
+        workbook = open_workbook(filename=self.file_name, file_contents=self.file_content)
+
+        if self.sheet_name:
+            # If a specific sheet name is provided, parse only that sheet
+            if self.sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(self.sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                return sheet_content
+            else:
+                raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
+        elif self.excel_by_sheets:
+            # Parse each sheet individually and return as a dictionary
+            result = {}
+            for sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                result[sheet_name] = sheet_content
+            return result
+        else:
+            # Combine all sheets into a single string result
+            result = []
+            for sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
+            return "\n\n".join(result)
+
+    def parse_sheet(self, sheet):
+        """
+        Parses a single .xlsx sheet, extracting text and hyperlinks, and formats them.
+        """
+        sheet_content = []
+
+        for row in sheet.iter_rows():
+            row_content = []
+            for cell in row:
+                if cell.hyperlink:
+                    # If the cell has a hyperlink, format it as Markdown
+                    hyperlink = cell.hyperlink.target
+                    cell_value = cell.value or ''  # Use cell value or empty string
+                    row_content.append(f"[{cell_value}]({hyperlink})")
+                else:
+                    # If no hyperlink, use the cell value (computed value if formula)
+                    row_content.append(str(cell.value) if cell.value is not None else "")
+            # Join the row content into a single line using `|` as the delimiter
+            sheet_content.append(cell_delimiter.join(row_content))
+
+        # Format the sheet content based on the return type
+        return self._format_sheet_content(sheet_content)
+
+    def parse_sheet_xls(self, sheet):
+        """
+        Parses a single .xls sheet using xlrd, extracting text and hyperlinks, and formats them.
+        """
+        sheet_content = []
+
+        # Extract hyperlink map (if available)
+        hyperlink_map = getattr(sheet, 'hyperlink_map', {})
+
+        for row_idx in range(sheet.nrows):
+            row_content = []
+            for col_idx in range(sheet.ncols):
+                cell = sheet.cell(row_idx, col_idx)
+                cell_value = cell.value
+
+                # Check if the cell has a hyperlink
+                cell_address = (row_idx, col_idx)
+                if cell_address in hyperlink_map:
+                    hyperlink = hyperlink_map[cell_address].url_or_path
+                    if cell_value:
+                        row_content.append(f"[{cell_value}]({hyperlink})")
+                else:
+                    row_content.append(str(cell_value) if cell_value is not None else "")
+            # Join the row content into a single line using `|` as the delimiter
+            sheet_content.append(cell_delimiter.join(row_content))
+
+        # Format the sheet content based on the return type
+        return self._format_sheet_content(sheet_content)
+
+    def _format_sheet_content(self, sheet_content):
+        """
+        Formats the sheet content based on the return type.
+        """
+        if self.return_type == 'dict':
+            # Convert to a list of dictionaries (each row is a dictionary)
+            headers = sheet_content[0].split(cell_delimiter) if sheet_content else []
+            data_rows = sheet_content[1:] if len(sheet_content) > 1 else []
+            return [dict(zip(headers, row.split(cell_delimiter))) for row in data_rows]
+        elif self.return_type == 'csv':
+            # Return as CSV (newline-separated rows, comma-separated values)
+            return "\n".join([",".join(row.split(cell_delimiter)) for row in sheet_content])
+        else:
+            # Default: Return as plain text (newline-separated rows, pipe-separated values)
+            return "\n".join(sheet_content)
+
+    def load(self) -> list:
+        docs = []
+        content_per_sheet = self.get_content()
+        for sheet_name, content in content_per_sheet.items():
+            metadata = {
+                "source": f'{self.file_path}:{sheet_name}',
+                "sheet_name": sheet_name,
+                "file_type": "excel",
+                "excel_by_sheets": self.excel_by_sheets,
+                "return_type": self.return_type,
+            }
+            docs.append(Document(page_content=f"Sheet: {sheet_name}\n {str(content)}", metadata=metadata))
+        return docs
+
+    def read(self, lazy: bool = False):
+        df = pd.read_excel(self.file_path, sheet_name=None, engine='calamine')
+        docs = []
+        for key in df.keys():
+            if self.raw_content:
+                docs.append(df[key].to_string())
+            else:
+                for record in loads(df[key].to_json(orient='records')):
+                    docs.append(record)
+        return docs
+
+    def read_lazy(self) -> Iterator[dict]:
+        df = pd.read_excel(self.file_path, sheet_name=None, engine='calamine')
+        for key in df.keys():
+            if self.raw_content:
+                yield df[key].to_string()
+            else:
+                for record in loads(df[key].to_json(orient='records')):
+                    yield record
+        return

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import Union, Any, Optional, Annotated, get_type_hints
 from uuid import uuid4
 from typing import Dict
@@ -274,11 +275,20 @@ class StateModifierNode(Runnable):
                 logger.warning(f"Failed to decode base64 value: {e}")
                 return value
         
+        def split_by_words(value, chunk_size=100):
+            words = value.split()
+            return [" ".join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]
+        
+        def split_by_regex(value, pattern):
+            """Splits the provided string using the specified regex pattern."""
+            return re.split(pattern, value)
 
         env = Environment()
         env.filters['from_json'] = from_json
-        env.filters['base64ToString'] = base64_to_string
-        
+        env.filters['base64_to_string'] = base64_to_string
+        env.filters['split_by_words'] = split_by_words
+        env.filters['split_by_regex'] = split_by_regex
+
         template = env.from_string(self.template)
         rendered_message = template.render(**input_data)
         result = {}

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/tools/artifact.py

@@ -3,6 +3,7 @@ import logging
 import re
 from typing import Any, Optional, Generator, List
 
+from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
 from pydantic import create_model, Field, model_validator
@@ -30,7 +31,21 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return self.artifact.list(bucket_name, return_as_string)
 
     def create_file(self, filename: str, filedata: str, bucket_name = None):
-        return self.artifact.create(filename, filedata, bucket_name)
+        result = self.artifact.create(filename, filedata, bucket_name)
+        
+        # Dispatch custom event for file creation
+        dispatch_custom_event("file_modified", {
+            "message": f"File '{filename}' created successfully",
+            "filename": filename,
+            "tool_name": "createFile",
+            "toolkit": "artifact",
+            "operation_type": "create",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
+        
+        return result
 
     def read_file(self,
                   filename: str,
@@ -51,10 +66,38 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return self.artifact.delete(filename, bucket_name)
 
     def append_data(self, filename: str, filedata: str, bucket_name = None):
-        return self.artifact.append(filename, filedata, bucket_name)
+        result = self.artifact.append(filename, filedata, bucket_name)
+        
+        # Dispatch custom event for file append
+        dispatch_custom_event("file_modified", {
+            "message": f"Data appended to file '{filename}' successfully",
+            "filename": filename,
+            "tool_name": "appendData",
+            "toolkit": "artifact",
+            "operation_type": "modify",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
+        
+        return result
 
     def overwrite_data(self, filename: str, filedata: str, bucket_name = None):
-        return self.artifact.overwrite(filename, filedata, bucket_name)
+        result = self.artifact.overwrite(filename, filedata, bucket_name)
+        
+        # Dispatch custom event for file overwrite
+        dispatch_custom_event("file_modified", {
+            "message": f"File '{filename}' overwritten successfully",
+            "filename": filename,
+            "tool_name": "overwriteData",
+            "toolkit": "artifact",
+            "operation_type": "modify",
+            "meta": {
+                "bucket": bucket_name or self.bucket
+            }
+        })
+        
+        return result
 
     def create_new_bucket(self, bucket_name: str, expiration_measure = "weeks", expiration_value = 1):
         return self.artifact.client.create_bucket(bucket_name, expiration_measure, expiration_value)

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/tools/vectorstore.py

@@ -137,7 +137,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
     embedding_model_params: dict
     vectorstore_type: str
     vectorstore_params: dict
-    max_docs_per_add: int = 100
+    max_docs_per_add: int = 20
     dataset: str = None
     embedding: Any = None
     vectorstore: Any = None

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/runtime/tools/vectorstore_base.py

@@ -135,7 +135,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
     embedding_model: Optional[str] = None
     vectorstore_type: Optional[str]  = None
     vectorstore_params: Optional[dict]  = None
-    max_docs_per_add: int = 100
+    max_docs_per_add: int = 20
     dataset: Optional[str] = None
     vectorstore: Any = None
     pg_helper: Any = None

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/tools/base_indexer_toolkit.py

@@ -279,7 +279,8 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         """Cleans the indexed data in the collection."""
         super()._clean_collection(collection_suffix=collection_suffix)
         return (f"Collection '{collection_suffix}' has been removed from the vector store.\n"
-                f"Available collections: {self.list_collections()}")
+                f"Available collections: {self.list_collections()}") if collection_suffix \
+            else "All collections have been removed from the vector store." 
 
     def _build_collection_filter(self, filter: dict | str, collection_suffix: str = "") -> dict:
         """Builds a filter for the collection based on the provided suffix."""

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk/tools/pandas/api_wrapper.py

@@ -93,7 +93,7 @@ class PandasWrapper(BaseToolApiWrapper):
             if file_extension in ['csv', 'txt']:
                 df = pd.read_csv(file_obj)
             elif file_extension in ['xlsx', 'xls']:
-                df = pd.read_excel(file_obj)
+                df = pd.read_excel(file_obj, engine='calamine')
             elif file_extension == 'parquet':
                 df = pd.read_parquet(file_obj)
             elif file_extension == 'json':
@@ -162,35 +162,17 @@ class PandasWrapper(BaseToolApiWrapper):
         """Analyze and process using query on dataset""" 
         df = self._get_dataframe(filename)
         code = self.generate_code_with_retries(df, query)
-        dispatch_custom_event(
-                name="thinking_step",
-                data={
-                    "message": f"Executing generated code... \n\n```python\n{code}\n```",
-                    "tool_name": "process_query",
-                    "toolkit": "pandas"
-                }
-            )
+        self._log_tool_event(tool_name="process_query",
+                             message=f"Executing generated code... \n\n```python\n{code}\n```")
         try:
             result = self.execute_code(df, code)
         except Exception as e:
             logger.error(f"Code execution failed: {format_exc()}")
-            dispatch_custom_event(
-                name="thinking_step",
-                data={
-                    "message": f"Code execution failed: {format_exc()}",
-                    "tool_name": "process_query",
-                    "toolkit": "pandas"
-                }
-            )
+            self._log_tool_event(tool_name="process_query",
+                                 message=f"Executing generated code... \n\n```python\n{code}\n```")
             raise
-        dispatch_custom_event(
-            name="thinking_step",
-            data={
-                "message": f"Result of code execution... \n\n```\n{result['result']}\n```",
-                "tool_name": "process_query",
-                "toolkit": "pandas"
-            }
-        )
+        self._log_tool_event(tool_name="process_query",
+                             message=f"Executing generated code... \n\n```python\n{code}\n```")
         if result.get("df") is not None:
             df = result.pop("df")
             # Not saving dataframe to artifact repo for now

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.347
+Version: 0.3.348rc1
 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
@@ -128,6 +128,7 @@ Requires-Dist: textract-py3==2.1.1; extra == "tools"
 Requires-Dist: slack_sdk==3.35.0; extra == "tools"
 Requires-Dist: deltalake==1.0.2; extra == "tools"
 Requires-Dist: google_cloud_bigquery==3.34.0; extra == "tools"
+Requires-Dist: python-calamine==0.5.3; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: pyobjtojson==0.3; extra == "community"

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk.egg-info/requires.txt

@@ -134,3 +134,4 @@ textract-py3==2.1.1
 slack_sdk==3.35.0
 deltalake==1.0.2
 google_cloud_bigquery==3.34.0
+python-calamine==0.5.3

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/alita_sdk.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 alita_sdk
 docs
 scripts
+src

{alita_sdk-0.3.347 → alita_sdk-0.3.348rc1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.347"
+version = "0.3.348-rc.1"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,7 +33,7 @@ email = "ad13box@gmail.com"
 
 [project.optional-dependencies]
 runtime = [ "streamlit>=1.28.0", "langchain_core>=0.3.76,<0.4.0", "langchain>=0.3.22,<0.4.0", "langchain_community>=0.3.7,<0.4.0", "langchain-openai>=0.3.0,<0.4.0", "langchain-anthropic>=0.3.10,<0.4.0", "anthropic>=0.57.0", "langgraph>=0.4.8,<0.5", "langgraph-prebuilt==0.5.2", "langgraph-checkpoint-sqlite~=2.0.0", "langgraph-checkpoint-postgres==2.0.21", "langsmith>=0.3.45", "langchain_chroma>=0.2.2,<0.3.0", "chromadb==0.5.20", "pgvector==0.2.5", "langchain-unstructured~=0.1.6", "langchain-postgres~=0.0.13", "unstructured[local-inference]==0.16.23", "unstructured_pytesseract==0.3.13", "unstructured_inference==0.8.7", "python-pptx==1.0.2", "python-docx==1.1.2", "openpyxl==3.1.2", "pypdf==4.3.1", "pdfminer.six==20240706", "pdf2image==1.16.3", "pikepdf==8.7.1", "docx2txt==0.8", "mammoth==1.9.0", "reportlab==4.2.5", "svglib==1.5.1", "cairocffi==1.7.1", "rlpycairo==0.3.0", "keybert==0.8.3", "sentence-transformers==2.7.0", "gensim==4.3.3", "scipy==1.13.1", "opencv-python==4.11.0.86", "pytesseract==0.3.13", "markdown==3.5.1", "beautifulsoup4==4.12.2", "charset_normalizer==3.3.2", "opentelemetry-exporter-otlp-proto-grpc==1.25.0", "opentelemetry_api==1.25.0", "opentelemetry_instrumentation==0.46b0", "grpcio_status==1.63.0rc1", "protobuf==4.25.7", "langchain-sandbox>=0.0.6",]
-tools = [ "dulwich==0.21.6", "paramiko==3.3.1", "pygithub==2.3.0", "python-gitlab==4.5.0", "gitpython==3.1.43", "atlassian-python-api~=4.0.7", "jira==3.8.0", "qtest-swagger-client==0.0.3", "testrail-api==1.13.4", "azure-devops==7.1.0b4", "msrest==0.7.1", "python-graphql-client~=0.4.3", "zephyr-python-api==0.1.0", "pyral==1.6.0", "boto3>=1.37.23", "azure-core==1.30.2", "azure-identity==1.16.0", "azure-keyvault-keys==4.9.0", "azure-keyvault-secrets==4.8.0", "azure-mgmt-core==1.4.0", "azure-mgmt-resource==23.0.1", "azure-mgmt-storage==21.1.0", "azure-storage-blob==12.23.1", "azure-search-documents==11.5.2", "PyMySQL==1.1.1", "psycopg2-binary==2.9.10", "Office365-REST-Python-Client==2.5.14", "pypdf2~=3.0.1", "FigmaPy==2018.1.0", "pandas==2.2.3", "factor_analyzer==0.5.1", "statsmodels==0.14.4", "tabulate==0.9.0", "tree_sitter==0.20.2", "tree-sitter-languages==1.10.2", "astor~=0.8.1", "markdownify~=1.1.0", "requests_openapi==1.0.5", "duckduckgo_search==5.3.0", "playwright>=1.52.0", "google-api-python-client==2.154.0", "wikipedia==1.4.0", "lxml==5.2.2", "pymupdf==1.24.9", "googlemaps==4.10.0", "yagmail==0.15.293", "pysnc==1.1.10", "shortuuid==1.0.13", "yarl==1.17.1", "langmem==0.0.27", "textract-py3==2.1.1", "slack_sdk==3.35.0", "deltalake==1.0.2", "google_cloud_bigquery==3.34.0",]
+tools = [ "dulwich==0.21.6", "paramiko==3.3.1", "pygithub==2.3.0", "python-gitlab==4.5.0", "gitpython==3.1.43", "atlassian-python-api~=4.0.7", "jira==3.8.0", "qtest-swagger-client==0.0.3", "testrail-api==1.13.4", "azure-devops==7.1.0b4", "msrest==0.7.1", "python-graphql-client~=0.4.3", "zephyr-python-api==0.1.0", "pyral==1.6.0", "boto3>=1.37.23", "azure-core==1.30.2", "azure-identity==1.16.0", "azure-keyvault-keys==4.9.0", "azure-keyvault-secrets==4.8.0", "azure-mgmt-core==1.4.0", "azure-mgmt-resource==23.0.1", "azure-mgmt-storage==21.1.0", "azure-storage-blob==12.23.1", "azure-search-documents==11.5.2", "PyMySQL==1.1.1", "psycopg2-binary==2.9.10", "Office365-REST-Python-Client==2.5.14", "pypdf2~=3.0.1", "FigmaPy==2018.1.0", "pandas==2.2.3", "factor_analyzer==0.5.1", "statsmodels==0.14.4", "tabulate==0.9.0", "tree_sitter==0.20.2", "tree-sitter-languages==1.10.2", "astor~=0.8.1", "markdownify~=1.1.0", "requests_openapi==1.0.5", "duckduckgo_search==5.3.0", "playwright>=1.52.0", "google-api-python-client==2.154.0", "wikipedia==1.4.0", "lxml==5.2.2", "pymupdf==1.24.9", "googlemaps==4.10.0", "yagmail==0.15.293", "pysnc==1.1.10", "shortuuid==1.0.13", "yarl==1.17.1", "langmem==0.0.27", "textract-py3==2.1.1", "slack_sdk==3.35.0", "deltalake==1.0.2", "google_cloud_bigquery==3.34.0", "python-calamine==0.5.3"]
 community = [ "retry-extended==0.2.3", "pyobjtojson==0.3", "elitea-analyse==0.1.2",]
 all = [ "alita-sdk[runtime]", "alita-sdk[tools]", "alita-sdk[community]",]
 dev = [ "pytest", "pytest-cov", "black", "flake8", "mypy",]

alita_sdk-0.3.347/alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py

@@ -1,136 +0,0 @@
-# Copyright (c) 2023 Artem Rozumenko
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import io
-from typing import Iterator
-import pandas as pd
-from json import loads
-
-from openpyxl import load_workbook
-from langchain_core.documents import Document
-from .AlitaTableLoader import AlitaTableLoader
-    
-cell_delimeter = " | "
-
-class AlitaExcelLoader(AlitaTableLoader):
-
-    excel_by_sheets: bool = False
-    sheet_name: str = None
-    return_type: str = 'str'
-
-    def __init__(self, **kwargs):
-        if not kwargs.get('file_path'):
-            file_content = kwargs.get('file_content')
-            if file_content:
-                kwargs['file_path'] = io.BytesIO(file_content)
-        super().__init__(**kwargs)
-        self.excel_by_sheets = kwargs.get('excel_by_sheets')
-        self.return_type = kwargs.get('return_type')
-        self.sheet_name = kwargs.get('sheet_name')
-
-    def get_content(self):
-        try:
-            # Load the workbook
-            workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
-
-            if self.sheet_name:
-                # If a specific sheet name is provided, parse only that sheet
-                if self.sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[self.sheet_name])
-                    return sheet_content
-                else:
-                    raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
-            elif self.excel_by_sheets:
-                # Parse each sheet individually and return as a dictionary
-                result = {}
-                for sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[sheet_name])
-                    result[sheet_name] = sheet_content
-                return result
-            else:
-                # Combine all sheets into a single string result
-                result = []
-                for sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[sheet_name])
-                    result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
-                return "\n\n".join(result)
-        except Exception as e:
-            return f"Error reading Excel file: {e}"
-
-    def parse_sheet(self, sheet):
-        """
-        Parses a single sheet, extracting text and hyperlinks, and formats them.
-        """
-        sheet_content = []
-
-        for row in sheet.iter_rows():
-            row_content = []
-            for cell in row:
-                if cell.hyperlink:
-                    # If the cell has a hyperlink, format it as Markdown
-                    hyperlink = cell.hyperlink.target
-                    cell_value = cell.value or ''  # Use cell value or empty string
-                    row_content.append(f"[{cell_value}]({hyperlink})")
-                else:
-                    # If no hyperlink, use the cell value (computed value if formula)
-                    row_content.append(str(cell.value) if cell.value is not None else "")
-            # Join the row content into a single line using `|` as the delimiter
-            sheet_content.append(cell_delimeter.join(row_content))
-
-        # Format the sheet content based on the return type
-        if self.return_type == 'dict':
-            # Convert to a list of dictionaries (each row is a dictionary)
-            headers = sheet_content[0].split(cell_delimeter) if sheet_content else []
-            data_rows = sheet_content[1:] if len(sheet_content) > 1 else []
-            return [dict(zip(headers, row.split(cell_delimeter))) for row in data_rows]
-        elif self.return_type == 'csv':
-            # Return as CSV (newline-separated rows, comma-separated values)
-            return "\n".join([",".join(row.split(cell_delimeter)) for row in sheet_content])
-        else:
-            # Default: Return as plain text (newline-separated rows, pipe-separated values)
-            return "\n".join(sheet_content)
-
-    def load(self) -> list:
-        docs = []
-        content_per_sheet = self.get_content()
-        for sheet_name, content in content_per_sheet.items():
-            metadata = {
-                "source": f'{self.file_path}:{sheet_name}',
-                "sheet_name": sheet_name,
-                "file_type": "excel",
-                "excel_by_sheets": self.excel_by_sheets,
-                "return_type": self.return_type,
-            }
-            docs.append(Document(page_content=f"Sheet: {sheet_name}\n {str(content)}", metadata=metadata))
-        return docs
-
-    def read(self, lazy: bool = False):
-        df = pd.read_excel(self.file_path, sheet_name=None)
-        docs = []
-        for key in df.keys():
-            if self.raw_content:
-                docs.append(df[key].to_string())
-            else:
-                for record in loads(df[key].to_json(orient='records')):
-                    docs.append(record)
-        return docs
-
-    def read_lazy(self) -> Iterator[dict]:
-        df = pd.read_excel(self.file_path, sheet_name=None)
-        for key in df.keys():
-            if self.raw_content:
-                yield df[key].to_string()
-            else:
-                for record in loads(df[key].to_json(orient='records')):
-                    yield record
-        return