alita-sdk 0.3.323__tar.gz → 0.3.325__tar.gz

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.323
+Version: 0.3.325
 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.323 → alita_sdk-0.3.325}/alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py

@@ -16,10 +16,11 @@ from typing import Iterator
 import pandas as pd
 from json import loads
 
-from langchain_core.tools import ToolException
+from openpyxl import load_workbook
 from langchain_core.documents import Document
 from .AlitaTableLoader import AlitaTableLoader
     
+cell_delimeter = " | "
 
 class AlitaExcelLoader(AlitaTableLoader):
 
@@ -39,32 +40,65 @@ class AlitaExcelLoader(AlitaTableLoader):
 
     def get_content(self):
         try:
-            dfs = pd.read_excel(self.file_path, sheet_name=self.sheet_name)
+            # Load the workbook
+            workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
 
-            if self.excel_by_sheets:
+            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, df in dfs.items():
-                    df.fillna('', inplace=True)
-                    result[sheet_name] = self.parse_sheet(df)
+                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, df in dfs.items():
-                    string_content = self.parse_sheet(df)
-                    result.append(f"====== Sheet name: {sheet_name} ======\n{string_content}")
+                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 ToolException(f"Error reading Excel file: {e}")
+            return f"Error reading Excel file: {e}"
 
-    def parse_sheet(self, df):
-        df.fillna('', inplace=True)
+    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':
-            return df.to_dict(orient='records')
+            # 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 df.to_csv()
+            # Return as CSV (newline-separated rows, comma-separated values)
+            return "\n".join([",".join(row.split(cell_delimeter)) for row in sheet_content])
         else:
-            return df.to_string(index=False)
+            # Default: Return as plain text (newline-separated rows, pipe-separated values)
+            return "\n".join(sheet_content)
 
     def load(self) -> list:
         docs = []

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/alita_sdk/runtime/langchain/document_loaders/AlitaPDFLoader.py

@@ -1,4 +1,5 @@
 import pymupdf
+import fitz
 from langchain_community.document_loaders import PyPDFLoader
 
 from .ImageParser import ImageParser
@@ -43,8 +44,59 @@ class AlitaPDFLoader:
         return text_content
 
     def read_pdf_page(self, report, page, index):
-        text_content = f'Page: {index}\n'
-        text_content += page.get_text()
+        # Extract text in block format (to more accurately match hyperlinks to text)
+        text_blocks = page.get_text("blocks")  # Returns a list of text blocks
+        words = page.get_text("words")  # Returns words with their coordinates
+
+        # Extract hyperlinks
+        links = page.get_links()
+
+        # Create a list to store the modified text
+        modified_text = []
+
+        for block in text_blocks:
+            block_rect = fitz.Rect(block[:4])  # Coordinates of the text block
+            block_text = block[4]  # The actual text of the block
+
+            # Check if there are hyperlinks intersecting with this text block
+            for link in links:
+                if "uri" in link:  # Ensure this is a hyperlink
+                    link_rect = link["from"]  # Coordinates of the hyperlink area
+                    link_uri = link["uri"]  # The URL of the hyperlink
+
+                    # Expand the hyperlink area slightly to account for inaccuracies
+                    link_rect = fitz.Rect(
+                        link_rect.x0 - 1, link_rect.y0 - 1, link_rect.x1 + 1, link_rect.y1 + 1
+                    )
+
+                    # Find words that are inside the hyperlink area
+                    link_text = []
+                    for word in words:
+                        word_rect = fitz.Rect(word[:4])  # Coordinates of the word
+                        word_text = word[4]
+
+                        # Check if the word rectangle is fully inside the hyperlink rectangle
+                        if link_rect.contains(word_rect):
+                            link_text.append(word_text)
+                        # If the word partially intersects, check vertical alignment
+                        elif link_rect.intersects(word_rect):
+                            # Condition: The word must be on the same line as the hyperlink
+                            if abs(link_rect.y0 - word_rect.y0) < 2 and abs(link_rect.y1 - word_rect.y1) < 2:
+                                link_text.append(word_text)
+
+                    # Format the hyperlink in Markdown
+                    full_text = " ".join(link_text) if link_text else "No text"
+                    hyperlink = f"[{full_text}]({link_uri})"
+
+                    # Replace the hyperlink text in the block with the formatted hyperlink
+                    block_text = block_text.replace(full_text, hyperlink)
+
+            # Add the processed text block to the result
+            modified_text.append(block_text)
+
+        # Combine all text blocks into the final text for the page
+        text_content = f'Page: {index}\n' + "\n".join(modified_text)
+
         if self.extract_images:
             images = page.get_images(full=True)
             for i, img in enumerate(images):

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/alita_sdk/runtime/tools/function.py

@@ -4,7 +4,7 @@ from json import dumps
 from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.messages import ToolCall
 from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import BaseTool
+from langchain_core.tools import BaseTool, ToolException
 from typing import Any, Optional, Union, Annotated
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import ValidationError
@@ -48,7 +48,13 @@ class FunctionTool(BaseTool):
                 return {"messages": [{"role": "assistant", "content": dumps(tool_result)}]}
             else:
                 if self.output_variables[0] == "messages":
-                    return {"messages": [{"role": "assistant", "content": dumps(tool_result)}]}
+                    return {
+                        "messages": [{
+                            "role": "assistant",
+                            "content": dumps(tool_result) if not isinstance(tool_result, ToolException) else str(
+                                tool_result)
+                        }]
+                    }
                 else:
                     return { self.output_variables[0]: tool_result }
         except ValidationError:

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/alita_sdk/runtime/utils/streamlit.py

@@ -1102,7 +1102,7 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                 st_cb = AlitaStreamlitCallback(st)
                 logger.info(st.session_state.messages)
                 response = st.session_state.agent_executor.invoke(
-                    {"input": prompt, "chat_history": st.session_state.messages[:-1]},
+                    {"input": [prompt], "chat_history": st.session_state.messages[:-1]},
                     { 'callbacks': [st_cb], 'configurable': {"thread_id": st.session_state.thread_id}}
                 )
                 st.write(response["output"])

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/alita_sdk/tools/confluence/api_wrapper.py

@@ -539,7 +539,9 @@ class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
         :param title: title
         :param type: type of content: page or blogpost. Defaults to page
         """
-        return self.client.get_page_id(space=self.space, title=title, type=type)
+
+        result = self.client.get_page_id(space=self.space, title=title, type=type)
+        return result if result else "Page not found. Check the title or space."
 
     def _strip_base64_images(self, content):
         base64_md_pattern = r'data:image/(png|jpeg|gif);base64,[a-zA-Z0-9+/=]+'
@@ -562,7 +564,7 @@ class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
                 }
                 pages_info.append(page_info)
             start += self.limit
-        return str(pages_info)
+        return str(pages_info) if pages_info else f"Unable to find anything using query {cql}. Check space or query."
 
     def search_pages(self, query: str, skip_images: bool = False):
         """Search pages in Confluence by query text in title or page content."""

{alita_sdk-0.3.323 → alita_sdk-0.3.325}/alita_sdk.egg-info/PKG-INFO

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

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