alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/runtime/langchain/document_loaders/AlitaJSONLoader.py

@@ -30,7 +30,12 @@ class AlitaJSONLoader(BaseLoader):
                 with open(self.file_path, encoding=self.encoding) as f:
                     return json.load(f)
             elif hasattr(self, 'file_content') and self.file_content:
-                return json.load(self.file_content)
+                if isinstance(self.file_content, bytes):
+                    return json.loads(self.file_content.decode(self.encoding))
+                elif isinstance(self.file_content, str):
+                    return json.loads(self.file_content)
+                else:
+                    return json.load(self.file_content)
             else:
                 raise ValueError("Neither file_path nor file_content is provided.")
 
@@ -42,7 +47,6 @@ class AlitaJSONLoader(BaseLoader):
                         try:
                             with open(self.file_path, encoding=encoding.encoding) as f:
                                 return f.read()
-                            break
                         except UnicodeDecodeError:
                             continue
                 elif hasattr(self, 'file_content') and self.file_content:
@@ -55,9 +59,11 @@ class AlitaJSONLoader(BaseLoader):
                 else:
                     raise ValueError("Neither file_path nor file_content is provided for encoding detection.")
             else:
-                raise RuntimeError(f"Error loading content with encoding {self.encoding}.") from e
+                raise RuntimeError(f"Error loading content with encoding {self.encoding}: {e}") from e
         except Exception as e:
-            raise RuntimeError(f"Error loading content.") from e
+            # Preserve original error details so callers (e.g., parse_file_content)
+            # can expose the real root cause instead of a generic message.
+            raise RuntimeError(f"Error loading content: {e}") from e
 
     def lazy_load(self) -> Iterator[Document]:
         """Load from file path."""

alita_sdk/runtime/langchain/document_loaders/AlitaPowerPointLoader.py

@@ -6,6 +6,7 @@ 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:
 
     def __init__(self, file_path=None, file_content=None, mode=None, **unstructured_kwargs):
@@ -43,10 +44,203 @@ class AlitaPowerPointLoader:
         else:
             raise ToolException(f"Unknown mode value: {self.mode}. Only 'single', 'paged' values allowed.")
 
+    def _extract_table_as_markdown(self, table) -> str:
+        """Convert PPTX table to markdown format."""
+        if not table.rows:
+            return ""
+        
+        rows = []
+        for row in table.rows:
+            cells = []
+            for cell in row.cells:
+                cell_text = cell.text.strip().replace("|", "\\|").replace("\n", " ")
+                cells.append(cell_text)
+            rows.append("| " + " | ".join(cells) + " |")
+        
+        if len(rows) > 0:
+            # Add header separator after first row
+            num_cols = len(table.rows[0].cells)
+            header_sep = "| " + " | ".join(["---"] * num_cols) + " |"
+            rows.insert(1, header_sep)
+        
+        return "\n**Table:**\n" + "\n".join(rows) + "\n"
+
+    def _extract_chart_info(self, chart) -> str:
+        """Extract data and labels from PPTX chart."""
+        result = []
+        
+        # Extract chart title
+        try:
+            if chart.has_title and chart.chart_title.has_text_frame:
+                title_text = chart.chart_title.text_frame.text.strip()
+                if title_text:
+                    result.append(f"Chart Title: {title_text}")
+        except Exception:
+            pass
+        
+        # Try to extract series data directly from chart.series (works for some chart types)
+        try:
+            if hasattr(chart, 'series') and chart.series:
+                for series in chart.series:
+                    series_name = series.name if series.name else "Unnamed Series"
+                    values = []
+                    categories = []
+                    
+                    # Try to get values
+                    try:
+                        if hasattr(series, 'values') and series.values:
+                            values = list(series.values)
+                    except Exception:
+                        pass
+                    
+                    # Try to get categories from series
+                    try:
+                        if hasattr(series, 'categories') and series.categories:
+                            categories = list(series.categories)
+                    except Exception:
+                        pass
+                    
+                    # Build output
+                    if categories and values and len(categories) == len(values):
+                        data_pairs = [f"{cat}: {val}" for cat, val in zip(categories, values)]
+                        result.append(f"Series '{series_name}': {', '.join(data_pairs)}")
+                    elif values:
+                        result.append(f"Series '{series_name}': {', '.join(str(v) for v in values)}")
+                    elif categories:
+                        result.append(f"Series '{series_name}' categories: {', '.join(str(c) for c in categories)}")
+        except Exception:
+            pass
+        
+        # Fallback: try plots API for bar/line charts
+        if not result or (len(result) == 1 and "Chart Title" in result[0]):
+            try:
+                if hasattr(chart, 'plots') and chart.plots and len(chart.plots) > 0:
+                    plot = chart.plots[0]
+                    categories = []
+                    if hasattr(plot, 'categories') and plot.categories:
+                        categories = list(plot.categories)
+                        if categories:
+                            result.append(f"Categories: {', '.join(str(c) for c in categories)}")
+                    
+                    # Extract series data from plot
+                    for series in plot.series:
+                        series_name = series.name if series.name else "Unnamed Series"
+                        values = list(series.values) if series.values else []
+                        
+                        if categories and len(categories) == len(values):
+                            data_pairs = [f"{cat}: {val}" for cat, val in zip(categories, values)]
+                            result.append(f"Series '{series_name}': {', '.join(data_pairs)}")
+                        elif values:
+                            result.append(f"Series '{series_name}': {', '.join(str(v) for v in values)}")
+            except Exception:
+                pass
+        
+        # Final fallback: parse XML directly for unsupported chart types (e.g., pie3DChart)
+        if not result or (len(result) == 1 and "Chart Title" in result[0]):
+            try:
+                result.extend(self._extract_chart_from_xml(chart))
+            except Exception:
+                pass
+        
+        # If we still have no data, add a note
+        if not result:
+            result.append("(Chart detected - there is no parsed data from this type of chart)")
+        
+        return "\n**Chart:**\n" + "\n".join(result) + "\n"
+
+    def _extract_chart_from_xml(self, chart) -> list:
+        """Extract chart data by parsing the underlying XML directly."""
+        result = []
+        
+        # Get the chart part XML
+        chart_part = chart.part
+        chart_element = chart_part.element
+        
+        # Define namespaces used in chart XML
+        namespaces = {
+            'c': 'http://schemas.openxmlformats.org/drawingml/2006/chart',
+            'a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
+        }
+        
+        # Find all series (ser) elements
+        series_elements = chart_element.findall('.//c:ser', namespaces)
+        
+        for ser in series_elements:
+            series_name = "Unnamed Series"
+            categories = []
+            values = []
+            
+            # Extract series name from tx/v or tx/strRef
+            tx = ser.find('.//c:tx', namespaces)
+            if tx is not None:
+                v = tx.find('.//c:v', namespaces)
+                if v is not None and v.text:
+                    series_name = v.text
+            
+            # Extract category labels from c:cat
+            cat = ser.find('.//c:cat', namespaces)
+            if cat is not None:
+                # Try strRef first (string references)
+                str_cache = cat.find('.//c:strCache', namespaces)
+                if str_cache is not None:
+                    for pt in str_cache.findall('.//c:pt', namespaces):
+                        v = pt.find('c:v', namespaces)
+                        if v is not None and v.text:
+                            categories.append(v.text)
+                
+                # Try numRef (numeric references used as categories)
+                if not categories:
+                    num_cache = cat.find('.//c:numCache', namespaces)
+                    if num_cache is not None:
+                        for pt in num_cache.findall('.//c:pt', namespaces):
+                            v = pt.find('c:v', namespaces)
+                            if v is not None and v.text:
+                                categories.append(v.text)
+            
+            # Extract values from c:val
+            val = ser.find('.//c:val', namespaces)
+            if val is not None:
+                num_cache = val.find('.//c:numCache', namespaces)
+                if num_cache is not None:
+                    for pt in num_cache.findall('.//c:pt', namespaces):
+                        v = pt.find('c:v', namespaces)
+                        if v is not None and v.text:
+                            try:
+                                values.append(float(v.text))
+                            except ValueError:
+                                values.append(v.text)
+            
+            # Build output
+            if categories and values and len(categories) == len(values):
+                data_pairs = [f"{cat}: {val}" for cat, val in zip(categories, values)]
+                result.append(f"Series '{series_name}': {', '.join(data_pairs)}")
+            elif values:
+                result.append(f"Series '{series_name}': {', '.join(str(v) for v in values)}")
+            elif categories:
+                result.append(f"Series '{series_name}' categories: {', '.join(str(c) for c in categories)}")
+        
+        return result
+
     def read_pptx_slide(self, slide, index):
         text_content = f'Slide: {index}\n'
         for shape in slide.shapes:
-            if hasattr(shape, "text_frame") and shape.text_frame is not None:
+            # Handle tables
+            if shape.has_table:
+                text_content += self._extract_table_as_markdown(shape.table)
+            # Handle charts
+            elif shape.has_chart:
+                text_content += self._extract_chart_info(shape.chart)
+            # Handle images - check multiple ways images can be embedded
+            elif self.extract_images and self._is_image_shape(shape):
+                try:
+                    image_blob = self._get_image_blob(shape)
+                    if image_blob:
+                        caption = perform_llm_prediction_for_image_bytes(image_blob, self.llm, self.prompt)
+                        text_content += "\n**Image Transcript:**\n" + caption + "\n--------------------\n"
+                except Exception:
+                    pass
+            # Handle text frames with hyperlinks
+            elif hasattr(shape, "text_frame") and shape.text_frame is not None:
                 for paragraph in shape.text_frame.paragraphs:
                     for run in paragraph.runs:
                         if run.hyperlink and run.hyperlink.address:
@@ -56,14 +250,39 @@ class AlitaPowerPointLoader:
                         else:
                             text_content += run.text
                 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, self.prompt)
-                except:
-                    caption = "unknown"
-                text_content += "\n**Image Transcript:**\n" + caption + "\n--------------------\n"
         return text_content + "\n"
 
+    def _is_image_shape(self, shape) -> bool:
+        """Check if shape contains an image using multiple detection methods."""
+        # Method 1: Check shape type
+        if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+            return True
+        # Method 2: Check if shape has image attribute with blob
+        if hasattr(shape, 'image') and shape.image is not None:
+            try:
+                if shape.image.blob:
+                    return True
+            except Exception:
+                pass
+        # Method 3: Check for placeholder with image
+        if hasattr(shape, 'placeholder_format') and shape.placeholder_format is not None:
+            try:
+                if hasattr(shape, 'image') and shape.image is not None:
+                    return True
+            except Exception:
+                pass
+        return False
+
+    def _get_image_blob(self, shape) -> bytes:
+        """Extract image blob from shape using available methods."""
+        # Try direct image access
+        if hasattr(shape, 'image') and shape.image is not None:
+            try:
+                return shape.image.blob
+            except Exception:
+                pass
+        return None
+
     def load(self):
         content = self.get_content()
         if isinstance(content, str):

alita_sdk/runtime/langchain/document_loaders/AlitaTextLoader.py

@@ -58,9 +58,12 @@ class AlitaTextLoader(BaseLoader):
                 else:
                     raise ValueError("Neither file_path nor file_content is provided for encoding detection.")
             else:
-                raise RuntimeError(f"Error loading content with encoding {self.encoding}.") from e
+                # Preserve original error details for callers
+                raise RuntimeError(f"Error loading content with encoding {self.encoding}: {e}") from e
         except Exception as e:
-            raise RuntimeError(f"Error loading content.") from e
+            # Preserve original error details so higher-level code (e.g., parse_file_content)
+            # can expose the real root cause instead of a generic message.
+            raise RuntimeError(f"Error loading content: {e}") from e
 
         return text
 

alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -21,12 +21,14 @@ from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
 from .AlitaJSONLoader import AlitaJSONLoader
+from .AlitaJSONLinesLoader import AlitaJSONLinesLoader
 from .AlitaPDFLoader import AlitaPDFLoader
 from .AlitaPowerPointLoader import AlitaPowerPointLoader
 from .AlitaTextLoader import AlitaTextLoader
 from .AlitaMarkdownLoader import AlitaMarkdownLoader
 from .AlitaPythonLoader import AlitaPythonLoader
 from enum import Enum
+from alita_sdk.runtime.langchain.constants import LOADER_MAX_TOKENS_DEFAULT
 
 
 class LoaderProperties(Enum):
@@ -34,7 +36,7 @@ class LoaderProperties(Enum):
     PROMPT_DEFAULT = 'use_default_prompt'
     PROMPT = 'prompt'
 
-DEFAULT_ALLOWED_BASE = {'max_tokens': 512}
+DEFAULT_ALLOWED_BASE = {'max_tokens': LOADER_MAX_TOKENS_DEFAULT}
 
 DEFAULT_ALLOWED_WITH_LLM = {
     **DEFAULT_ALLOWED_BASE,
@@ -43,7 +45,9 @@ DEFAULT_ALLOWED_WITH_LLM = {
     LoaderProperties.PROMPT.value: "",
 }
 
-# Image file loaders mapping
+DEFAULT_ALLOWED_EXCEL = {**DEFAULT_ALLOWED_WITH_LLM, 'add_header_to_chunks': False, 'header_row_number': 1, 'max_tokens': -1, 'sheet_name': ''}
+
+# Image file loaders mapping - directly supported by LLM with image_url
 image_loaders_map = {
     '.png': {
         'class': AlitaImageLoader,
@@ -73,6 +77,17 @@ image_loaders_map = {
         'kwargs': {},
         'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
+    '.webp': {
+        'class': AlitaImageLoader,
+        'mime_type': 'image/webp',
+        'is_multimodal_processing': True,
+        'kwargs': {},
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
+    }
+}
+
+# Image file loaders mapping - require conversion before sending to LLM
+image_loaders_map_converted = {
     '.bmp': {
         'class': AlitaImageLoader,
         'mime_type': 'image/bmp',
@@ -102,7 +117,7 @@ document_loaders_map = {
     },
     '.yml': {
         'class': AlitaTextLoader,
-        'mime_type': 'application/x-yaml',
+        'mime_type': 'application/yaml',
         'is_multimodal_processing': False,
         'kwargs': {
             'autodetect_encoding': True
@@ -111,7 +126,7 @@ document_loaders_map = {
     },
     '.yaml': {
         'class': AlitaTextLoader,
-        'mime_type': 'application/x-yaml',
+        'mime_type': 'application/yaml',
         'is_multimodal_processing': False,
         'kwargs': {
             'autodetect_encoding': True
@@ -151,11 +166,12 @@ document_loaders_map = {
                       'spreadsheetml.sheet'),
         'is_multimodal_processing': False,
         'kwargs': {
-            'excel_by_sheets': True,
-            'raw_content': True,
-            'cleanse': False
+            'add_header_to_chunks': False,
+            'header_row_number': 1,
+            'max_tokens': -1,
+            'sheet_name': ''
         },
-        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
+        'allowed_to_override': DEFAULT_ALLOWED_EXCEL
     },
     '.xls': {
         'class': AlitaExcelLoader,
@@ -166,7 +182,7 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
+        'allowed_to_override': DEFAULT_ALLOWED_EXCEL
     },
     '.pdf': {
         'class': AlitaPDFLoader,
@@ -193,7 +209,7 @@ document_loaders_map = {
         'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.jsonl': {
-        'class': AirbyteJSONLoader,
+        'class': AlitaJSONLinesLoader,
         'mime_type': 'application/jsonl',
         'is_multimodal_processing': False,
         'kwargs': {},
@@ -244,17 +260,17 @@ document_loaders_map = {
             'extract_images': False,
         }
     },
-    '.py': {
-        'class': AlitaPythonLoader,
-        'mime_type': 'text/x-python',
-        'is_multimodal_processing': False,
-        'kwargs': {},
-        'allowed_to_override': DEFAULT_ALLOWED_BASE
-    }
+    # '.py': {
+    #     'class': AlitaPythonLoader,
+    #     'mime_type': 'text/x-python',
+    #     'is_multimodal_processing': False,
+    #     'kwargs': {},
+    #     'allowed_to_override': DEFAULT_ALLOWED_BASE
+    # }
 }
 
 code_extensions = [
-    # '.py',  # Python
+    '.py',  # Python
     '.js',  # JavaScript
     '.ts',  # TypeScript
     '.java',  # Java
@@ -292,7 +308,12 @@ default_loader_config = {
 code_loaders_map = {ext: default_loader_config for ext in code_extensions}
 
 # Combined mapping for backward compatibility
-loaders_map = {**image_loaders_map, **document_loaders_map, **code_loaders_map}
+loaders_map = {
+    **image_loaders_map,
+    **image_loaders_map_converted,
+    **document_loaders_map,
+    **code_loaders_map
+}
 
 loaders_allowed_to_override = {
     extension: config.get('allowed_to_override')