mb-rag 1.1.23__tar.gz → 1.1.26__tar.gz

{mb_rag-1.1.23 → mb_rag-1.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mb_rag
-Version: 1.1.23
+Version: 1.1.26
 Summary: RAG function file
 Author: ['Malav Bateriwala']
 Requires-Python: >=3.8

{mb_rag-1.1.23 → mb_rag-1.1.26}/mb_rag/chatbot/basic.py

@@ -218,12 +218,12 @@ class ModelFactory:
         if not check_package("transformers"):
             raise ImportError("Transformers package not found. Please install it using: pip install transformers")
         if not check_package("langchain_huggingface"):
-            raise ImportError("Transformers package not found. Please install it using: pip install langchain_huggingface")
+            raise ImportError("langchain_huggingface package not found. Please install it using: pip install langchain_huggingface")
         if not check_package("torch"):
             raise ImportError("Torch package not found. Please install it using: pip install torch")
 
         from langchain_huggingface import HuggingFacePipeline
-        from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoModelForImageTextToText
+        from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoModelForImageTextToText,AutoProcessor
         import torch
         
         device = torch.device(device) if torch.cuda.is_available() else torch.device("cpu")
@@ -231,8 +231,8 @@ class ModelFactory:
         temperature = kwargs.pop("temperature", 0.7)
         max_length = kwargs.pop("max_length", 1024)
         
-        tokenizer = AutoTokenizer.from_pretrained(model_name,trust_remote_code=True)
         if model_function == "image-text-to-text":
+            tokenizer = AutoProcessor.from_pretrained(model_name,trust_remote_code=True)
             model = AutoModelForImageTextToText.from_pretrained(
                 model_name,
                 torch_dtype=torch.float16 if device == "cuda" else torch.float32,
@@ -241,6 +241,7 @@ class ModelFactory:
                 **kwargs
             )
         else:
+            tokenizer = AutoTokenizer.from_pretrained(model_name,trust_remote_code=True)
             model = AutoModelForCausalLM.from_pretrained(
                 model_name,
                 torch_dtype=torch.float16 if device == "cuda" else torch.float32,

{mb_rag-1.1.23 → mb_rag-1.1.26}/mb_rag/rag/embeddings.py

@@ -585,7 +585,7 @@ class embedding_generator:
             if not ModelProvider.check_package("langchain_openai"):
                 raise ImportError("OpenAI package not found. Please install: pip install langchain-openai")
             from langchain_openai import ChatOpenAI
-            llm = ChatOpenAI(model="gpt-4")
+            llm = ChatOpenAI(model="gpt-4o", temperature=0.8)
 
         history_aware_retriever = create_history_aware_retriever(llm, retriever,
                                                                contextualize_q_prompt)

mb_rag-1.1.26/mb_rag/utils/document_extract.py

@@ -0,0 +1,354 @@
+"""
+Document Extraction Module
+
+This module provides functionality for extracting text and metadata from various document types
+including CSV, PowerPoint (PPT/PPTX), and other document formats. It complements the PDF extraction
+functionality in pdf_extract.py.
+
+Example Usage:
+    ```python
+    # Initialize CSV extractor
+    csv_extractor = CSVExtractor()
+    
+    # Extract data from a CSV file
+    docs = csv_extractor.extract_csv("data.csv")
+    
+    # Initialize PowerPoint extractor
+    ppt_extractor = PowerPointExtractor()
+    
+    # Extract content from a PowerPoint file
+    docs = ppt_extractor.extract_ppt("presentation.pptx")
+    ```
+
+Features:
+    - CSV file extraction with metadata
+    - PowerPoint (PPT/PPTX) extraction
+    - Batch processing for multiple files
+"""
+
+import os
+import pandas as pd
+import importlib.util
+from typing import List, Dict, Optional, Union, Any
+from langchain_core.documents import Document
+
+class CSVExtractor:
+    """
+    Class for extracting data from CSV files.
+    
+    This class provides methods for extracting content from CSV files
+    and converting it to Document objects for use with RAG systems.
+    
+    Args:
+        logger: Optional logger instance for logging operations
+        
+    Example:
+        ```python
+        extractor = CSVExtractor()
+        docs = extractor.extract_csv("data.csv")
+        ```
+    """
+    
+    def __init__(self, logger=None):
+        """Initialize the CSV extractor."""
+        self.logger = logger
+    
+    def check_file(self, file_path: str) -> bool:
+        """
+        Check if file exists.
+        
+        Args:
+            file_path (str): Path to the file
+            
+        Returns:
+            bool: True if file exists, False otherwise
+        """
+        return os.path.exists(file_path)
+    
+    def extract_csv(self, csv_path: str, include_stats: bool = True, 
+                   chunk_by_row: bool = False, rows_per_chunk: int = 10,
+                   **kwargs) -> List[Document]:
+        """
+        Extract data from a CSV file.
+        
+        Args:
+            csv_path (str): Path to the CSV file
+            include_stats (bool): Whether to include basic statistics in the metadata
+            chunk_by_row (bool): Whether to create a separate document for each row or group of rows
+            rows_per_chunk (int): Number of rows per chunk if chunk_by_row is True
+            **kwargs: Additional arguments for pandas.read_csv
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+            
+        Raises:
+            ValueError: If the file doesn't exist
+            ImportError: If pandas is not installed
+        """
+        if not self.check_file(csv_path):
+            raise ValueError(f"File {csv_path} not found")
+        
+        try:
+            # Read CSV file
+            df = pd.read_csv(csv_path, **kwargs)
+            
+            # Create metadata
+            metadata = {
+                "source": csv_path,
+                "rows": len(df),
+                "columns": list(df.columns),
+                "file_type": "csv"
+            }
+            
+            # Add basic statistics if requested
+            if include_stats:
+                stats = {}
+                for column in df.columns:
+                    if pd.api.types.is_numeric_dtype(df[column]):
+                        stats[column] = {
+                            "min": float(df[column].min()),
+                            "max": float(df[column].max()),
+                            "mean": float(df[column].mean()),
+                            "median": float(df[column].median())
+                        }
+                metadata["statistics"] = stats
+            
+            documents = []
+            
+            if chunk_by_row:
+                # Create a separate document for each chunk of rows
+                for i in range(0, len(df), rows_per_chunk):
+                    chunk = df.iloc[i:i+rows_per_chunk]
+                    chunk_text = chunk.to_string(index=False)
+                    
+                    chunk_metadata = metadata.copy()
+                    chunk_metadata["chunk"] = {
+                        "start_row": i,
+                        "end_row": min(i + rows_per_chunk - 1, len(df) - 1),
+                        "total_rows": len(chunk)
+                    }
+                    
+                    documents.append(Document(
+                        page_content=chunk_text,
+                        metadata=chunk_metadata
+                    ))
+            else:
+                # Create a single document with all data
+                text = df.to_string(index=False)
+                documents.append(Document(
+                    page_content=text,
+                    metadata=metadata
+                ))
+            
+            if self.logger:
+                self.logger.info(f"Extracted data from {csv_path}")
+            else:
+                print(f"Extracted data from {csv_path}")
+                
+            return documents
+            
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error extracting from {csv_path}: {str(e)}")
+            else:
+                print(f"Error extracting from {csv_path}: {str(e)}")
+            raise
+    
+    def extract_multiple_csvs(self, csv_paths: List[str], **kwargs) -> List[Document]:
+        """
+        Extract data from multiple CSV files.
+        
+        Args:
+            csv_paths (List[str]): List of paths to CSV files
+            **kwargs: Additional arguments for extract_csv
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+        """
+        all_docs = []
+        for csv_path in csv_paths:
+            try:
+                docs = self.extract_csv(csv_path, **kwargs)
+                all_docs.extend(docs)
+                if self.logger:
+                    self.logger.info(f"Successfully extracted content from {csv_path}")
+                else:
+                    print(f"Successfully extracted content from {csv_path}")
+            except Exception as e:
+                if self.logger:
+                    self.logger.error(f"Error extracting from {csv_path}: {str(e)}")
+                else:
+                    print(f"Error extracting from {csv_path}: {str(e)}")
+        
+        return all_docs
+
+
+class PowerPointExtractor:
+    """
+    Class for extracting content from PowerPoint (PPT/PPTX) files.
+    
+    This class provides methods for extracting text, notes, and metadata
+    from PowerPoint presentations.
+    
+    Args:
+        logger: Optional logger instance for logging operations
+        
+    Example:
+        ```python
+        extractor = PowerPointExtractor()
+        docs = extractor.extract_ppt("presentation.pptx")
+        ```
+    """
+    
+    def __init__(self, logger=None):
+        """Initialize the PowerPoint extractor."""
+        self.logger = logger
+    
+    @staticmethod
+    def check_package(package_name: str) -> bool:
+        """
+        Check if a Python package is installed.
+        
+        Args:
+            package_name (str): Name of the package to check
+            
+        Returns:
+            bool: True if package is installed, False otherwise
+        """
+        return importlib.util.find_spec(package_name) is not None
+    
+    def check_file(self, file_path: str) -> bool:
+        """
+        Check if file exists.
+        
+        Args:
+            file_path (str): Path to the file
+            
+        Returns:
+            bool: True if file exists, False otherwise
+        """
+        return os.path.exists(file_path)
+    
+    def extract_ppt(self, ppt_path: str, include_notes: bool = True,
+                   include_hidden_slides: bool = False,
+                   extract_images: bool = False) -> List[Document]:
+        """
+        Extract content from a PowerPoint file.
+        
+        Args:
+            ppt_path (str): Path to the PowerPoint file
+            include_notes (bool): Whether to include speaker notes
+            include_hidden_slides (bool): Whether to include hidden slides
+            extract_images (bool): Whether to extract images
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+            
+        Raises:
+            ValueError: If the file doesn't exist
+            ImportError: If python-pptx is not installed
+        """
+        if not self.check_file(ppt_path):
+            raise ValueError(f"File {ppt_path} not found")
+        
+        if not self.check_package("pptx"):
+            raise ImportError("python-pptx package not found. Please install: pip install python-pptx")
+        
+        from pptx import Presentation
+        
+        try:
+            # Load presentation
+            presentation = Presentation(ppt_path)
+            
+            documents = []
+            
+            # Process each slide
+            for i, slide in enumerate(presentation.slides):
+                # Skip hidden slides if not requested
+                if hasattr(slide, 'show') and not slide.show and not include_hidden_slides:
+                    continue
+                
+                # Extract text from shapes
+                texts = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text:
+                        texts.append(shape.text)
+                
+                # Extract notes if requested
+                notes = ""
+                if include_notes and hasattr(slide, "notes_slide") and slide.notes_slide:
+                    for note_shape in slide.notes_slide.notes_text_frame.paragraphs:
+                        if note_shape.text:
+                            notes += note_shape.text + "\n"
+                
+                # Create metadata
+                metadata = {
+                    "source": ppt_path,
+                    "slide_number": i + 1,
+                    "total_slides": len(presentation.slides),
+                    "file_type": "pptx" if ppt_path.endswith(".pptx") else "ppt"
+                }
+                
+                # Add slide title if available
+                if slide.shapes.title and slide.shapes.title.text:
+                    metadata["title"] = slide.shapes.title.text
+                
+                # Combine text content
+                content = f"Slide {i+1}"
+                if "title" in metadata:
+                    content += f": {metadata['title']}"
+                content += "\n\n"
+                
+                if texts:
+                    content += "\n".join(texts) + "\n"
+                
+                if notes:
+                    content += "\nNotes:\n" + notes
+                
+                # Create document
+                documents.append(Document(
+                    page_content=content,
+                    metadata=metadata
+                ))
+            
+            if self.logger:
+                self.logger.info(f"Extracted {len(documents)} slides from {ppt_path}")
+            else:
+                print(f"Extracted {len(documents)} slides from {ppt_path}")
+                
+            return documents
+            
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error extracting from {ppt_path}: {str(e)}")
+            else:
+                print(f"Error extracting from {ppt_path}: {str(e)}")
+            raise
+    
+    def extract_multiple_ppts(self, ppt_paths: List[str], **kwargs) -> List[Document]:
+        """
+        Extract content from multiple PowerPoint files.
+        
+        Args:
+            ppt_paths (List[str]): List of paths to PowerPoint files
+            **kwargs: Additional arguments for extract_ppt
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+        """
+        all_docs = []
+        for ppt_path in ppt_paths:
+            try:
+                docs = self.extract_ppt(ppt_path, **kwargs)
+                all_docs.extend(docs)
+                if self.logger:
+                    self.logger.info(f"Successfully extracted content from {ppt_path}")
+                else:
+                    print(f"Successfully extracted content from {ppt_path}")
+            except Exception as e:
+                if self.logger:
+                    self.logger.error(f"Error extracting from {ppt_path}: {str(e)}")
+                else:
+                    print(f"Error extracting from {ppt_path}: {str(e)}")
+        
+        return all_docs

mb_rag-1.1.26/mb_rag/utils/pdf_extract.py

@@ -0,0 +1,428 @@
+"""
+PDF Extraction Module
+
+This module provides functionality for extracting text and metadata from PDF files.
+It supports various extraction methods and includes features for handling different
+PDF structures, including tables and images.
+
+Example Usage:
+    ```python
+    # Initialize PDF extractor
+    extractor = PDFExtractor()
+    
+    # Extract text from a PDF file
+    docs = extractor.extract_pdf("document.pdf")
+    
+    # Extract with specific options
+    docs = extractor.extract_pdf(
+        "document.pdf",
+        extraction_method="pdfplumber",
+        extract_images=True
+    )
+    
+    # Extract from multiple PDFs
+    docs = extractor.extract_multiple_pdfs(
+        ["doc1.pdf", "doc2.pdf"],
+        extraction_method="pymupdf"
+    )
+    ```
+
+Features:
+    - Multiple extraction methods (PyPDF2, PDFPlumber, PyMuPDF)
+    - Text and metadata extraction
+    - Optional image extraction
+    - Table detection and extraction
+    - Batch processing for multiple PDFs
+"""
+
+import os
+import tempfile
+from typing import List, Dict, Optional, Union, Any, Tuple
+import importlib.util
+from langchain_core.documents import Document
+
+class PDFExtractor:
+    """
+    Class for extracting text and metadata from PDF files.
+    
+    This class provides methods for extracting content from PDF files using
+    different extraction methods and processing options.
+    
+    Args:
+        logger: Optional logger instance for logging operations
+        
+    Example:
+        ```python
+        extractor = PDFExtractor()
+        docs = extractor.extract_pdf("document.pdf")
+        ```
+    """
+    
+    def __init__(self, logger=None):
+        """Initialize the PDF extractor."""
+        self.logger = logger
+        
+    @staticmethod
+    def check_package(package_name: str) -> bool:
+        """
+        Check if a Python package is installed.
+        
+        Args:
+            package_name (str): Name of the package to check
+            
+        Returns:
+            bool: True if package is installed, False otherwise
+        """
+        return importlib.util.find_spec(package_name) is not None
+    
+    def check_file(self, file_path: str) -> bool:
+        """
+        Check if file exists.
+        
+        Args:
+            file_path (str): Path to the file
+            
+        Returns:
+            bool: True if file exists, False otherwise
+        """
+        return os.path.exists(file_path)
+    
+    def extract_pdf(self, pdf_path: str, extraction_method: str = "pypdf", 
+                   extract_images: bool = False, extract_tables: bool = False,
+                   **kwargs) -> List[Document]:
+        """
+        Extract text and metadata from a PDF file.
+        
+        Args:
+            pdf_path (str): Path to the PDF file
+            extraction_method (str): Method to use for extraction 
+                                    ("pypdf", "pdfplumber", or "pymupdf")
+            extract_images (bool): Whether to extract images
+            extract_tables (bool): Whether to extract tables
+            **kwargs: Additional arguments for the extraction method
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+            
+        Raises:
+            ValueError: If the file doesn't exist or extraction method is invalid
+            ImportError: If required packages are not installed
+        """
+        if not self.check_file(pdf_path):
+            raise ValueError(f"File {pdf_path} not found")
+        
+        if extraction_method == "pypdf":
+            return self._extract_with_pypdf(pdf_path, **kwargs)
+        elif extraction_method == "pdfplumber":
+            return self._extract_with_pdfplumber(pdf_path, extract_tables, **kwargs)
+        elif extraction_method == "pymupdf":
+            return self._extract_with_pymupdf(pdf_path, extract_images, **kwargs)
+        else:
+            raise ValueError(f"Invalid extraction method: {extraction_method}")
+    
+    def extract_multiple_pdfs(self, pdf_paths: List[str], extraction_method: str = "pypdf",
+                             extract_images: bool = False, extract_tables: bool = False,
+                             **kwargs) -> List[Document]:
+        """
+        Extract text and metadata from multiple PDF files.
+        
+        Args:
+            pdf_paths (List[str]): List of paths to PDF files
+            extraction_method (str): Method to use for extraction
+            extract_images (bool): Whether to extract images
+            extract_tables (bool): Whether to extract tables
+            **kwargs: Additional arguments for the extraction method
+            
+        Returns:
+            List[Document]: List of Document objects containing extracted content
+        """
+        all_docs = []
+        for pdf_path in pdf_paths:
+            try:
+                docs = self.extract_pdf(
+                    pdf_path, 
+                    extraction_method=extraction_method,
+                    extract_images=extract_images,
+                    extract_tables=extract_tables,
+                    **kwargs
+                )
+                all_docs.extend(docs)
+                if self.logger:
+                    self.logger.info(f"Successfully extracted content from {pdf_path}")
+                else:
+                    print(f"Successfully extracted content from {pdf_path}")
+            except Exception as e:
+                if self.logger:
+                    self.logger.error(f"Error extracting from {pdf_path}: {str(e)}")
+                else:
+                    print(f"Error extracting from {pdf_path}: {str(e)}")
+        
+        return all_docs
+    
+    def _extract_with_pypdf(self, pdf_path: str, **kwargs) -> List[Document]:
+        """
+        Extract text using PyPDF2.
+        
+        Args:
+            pdf_path (str): Path to the PDF file
+            **kwargs: Additional arguments for PyPDF2
+            
+        Returns:
+            List[Document]: List of Document objects
+            
+        Raises:
+            ImportError: If PyPDF2 is not installed
+        """
+        if not self.check_package("pypdf"):
+            raise ImportError("PyPDF2 package not found. Please install: pip install pypdf")
+        
+        from langchain_community.document_loaders import PyPDFLoader
+        
+        loader = PyPDFLoader(pdf_path, **kwargs)
+        documents = loader.load()
+        
+        if self.logger:
+            self.logger.info(f"Extracted {len(documents)} pages from {pdf_path} using PyPDF2")
+        else:
+            print(f"Extracted {len(documents)} pages from {pdf_path} using PyPDF2")
+            
+        return documents
+    
+    def _extract_with_pdfplumber(self, pdf_path: str, extract_tables: bool = False, **kwargs) -> List[Document]:
+        """
+        Extract text using PDFPlumber.
+        
+        Args:
+            pdf_path (str): Path to the PDF file
+            extract_tables (bool): Whether to extract tables
+            **kwargs: Additional arguments for PDFPlumber
+            
+        Returns:
+            List[Document]: List of Document objects
+            
+        Raises:
+            ImportError: If PDFPlumber is not installed
+        """
+        if not self.check_package("pdfplumber"):
+            raise ImportError("PDFPlumber package not found. Please install: pip install pdfplumber")
+        
+        import pdfplumber
+        
+        documents = []
+        with pdfplumber.open(pdf_path) as pdf:
+            for i, page in enumerate(pdf.pages):
+                text = page.extract_text()
+                
+                metadata = {
+                    "source": pdf_path,
+                    "page": i + 1,
+                    "total_pages": len(pdf.pages)
+                }
+                
+                if extract_tables:
+                    tables = page.extract_tables()
+                    if tables:
+                        table_text = []
+                        for table in tables:
+                            table_rows = []
+                            for row in table:
+                                # Filter out None values and convert to strings
+                                row_text = [str(cell) if cell is not None else "" for cell in row]
+                                table_rows.append(" | ".join(row_text))
+                            table_text.append("\n".join(table_rows))
+                        
+                        metadata["tables"] = table_text
+                        # Append table text to the main text
+                        text += "\n\nTABLES:\n" + "\n\n".join(table_text)
+                
+                documents.append(Document(page_content=text, metadata=metadata))
+        
+        if self.logger:
+            self.logger.info(f"Extracted {len(documents)} pages from {pdf_path} using PDFPlumber")
+        else:
+            print(f"Extracted {len(documents)} pages from {pdf_path} using PDFPlumber")
+            
+        return documents
+    
+    def _extract_with_pymupdf(self, pdf_path: str, extract_images: bool = False, **kwargs) -> List[Document]:
+        """
+        Extract text using PyMuPDF (fitz).
+        
+        Args:
+            pdf_path (str): Path to the PDF file
+            extract_images (bool): Whether to extract images
+            **kwargs: Additional arguments for PyMuPDF
+            
+        Returns:
+            List[Document]: List of Document objects
+            
+        Raises:
+            ImportError: If PyMuPDF is not installed
+        """
+        if not self.check_package("fitz"):
+            raise ImportError("PyMuPDF package not found. Please install: pip install pymupdf")
+        
+        import fitz
+        
+        documents = []
+        temp_dir = None
+        
+        try:
+            if extract_images:
+                temp_dir = tempfile.mkdtemp()
+            
+            with fitz.open(pdf_path) as doc:
+                for i, page in enumerate(doc):
+                    text = page.get_text()
+                    
+                    metadata = {
+                        "source": pdf_path,
+                        "page": i + 1,
+                        "total_pages": len(doc),
+                        "title": doc.metadata.get("title", ""),
+                        "author": doc.metadata.get("author", ""),
+                        "subject": doc.metadata.get("subject", ""),
+                        "keywords": doc.metadata.get("keywords", "")
+                    }
+                    
+                    if extract_images and temp_dir:
+                        image_list = page.get_images(full=True)
+                        image_paths = []
+                        
+                        for img_index, img in enumerate(image_list):
+                            xref = img[0]
+                            base_image = doc.extract_image(xref)
+                            image_bytes = base_image["image"]
+                            
+                            image_path = os.path.join(
+                                temp_dir, 
+                                f"page{i+1}_img{img_index+1}.{base_image['ext']}"
+                            )
+                            
+                            with open(image_path, "wb") as img_file:
+                                img_file.write(image_bytes)
+                            
+                            image_paths.append(image_path)
+                        
+                        if image_paths:
+                            metadata["images"] = image_paths
+                    
+                    documents.append(Document(page_content=text, metadata=metadata))
+        
+        finally:
+            # Clean up temporary directory if it was created
+            if extract_images and temp_dir and os.path.exists(temp_dir):
+                import shutil
+                shutil.rmtree(temp_dir)
+        
+        if self.logger:
+            self.logger.info(f"Extracted {len(documents)} pages from {pdf_path} using PyMuPDF")
+        else:
+            print(f"Extracted {len(documents)} pages from {pdf_path} using PyMuPDF")
+            
+        return documents
+
+
+class PDFToCSV:
+    """
+    Class for converting PDF tables to CSV format.
+    
+    This class provides methods for extracting tables from PDF files
+    and converting them to CSV format.
+    
+    Args:
+        logger: Optional logger instance for logging operations
+        
+    Example:
+        ```python
+        converter = PDFToCSV()
+        csv_paths = converter.convert_pdf_tables_to_csv("document.pdf", "output_dir")
+        ```
+    """
+    
+    def __init__(self, logger=None):
+        """Initialize the PDF to CSV converter."""
+        self.logger = logger
+        
+    @staticmethod
+    def check_package(package_name: str) -> bool:
+        """
+        Check if a Python package is installed.
+        
+        Args:
+            package_name (str): Name of the package to check
+            
+        Returns:
+            bool: True if package is installed, False otherwise
+        """
+        return importlib.util.find_spec(package_name) is not None
+    
+    def convert_pdf_tables_to_csv(self, pdf_path: str, output_dir: str = None, 
+                                 pages: List[int] = None) -> List[str]:
+        """
+        Extract tables from PDF and convert to CSV.
+        
+        Args:
+            pdf_path (str): Path to the PDF file
+            output_dir (str): Directory to save CSV files (default: same as PDF)
+            pages (List[int]): Specific pages to extract tables from (default: all)
+            
+        Returns:
+            List[str]: Paths to the created CSV files
+            
+        Raises:
+            ImportError: If required packages are not installed
+            ValueError: If the PDF file doesn't exist
+        """
+        if not os.path.exists(pdf_path):
+            raise ValueError(f"PDF file not found: {pdf_path}")
+        
+        if not self.check_package("tabula"):
+            raise ImportError("Tabula-py package not found. Please install: pip install tabula-py")
+        
+        import tabula
+        import pandas as pd
+        
+        # Determine output directory
+        if output_dir is None:
+            output_dir = os.path.dirname(pdf_path)
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Extract tables
+        try:
+            if pages:
+                dfs = tabula.read_pdf(pdf_path, pages=pages, multiple_tables=True)
+            else:
+                dfs = tabula.read_pdf(pdf_path, pages='all', multiple_tables=True)
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error extracting tables: {str(e)}")
+            else:
+                print(f"Error extracting tables: {str(e)}")
+            return []
+        
+        if not dfs:
+            if self.logger:
+                self.logger.warning(f"No tables found in {pdf_path}")
+            else:
+                print(f"No tables found in {pdf_path}")
+            return []
+        
+        # Save tables to CSV
+        csv_paths = []
+        pdf_name = os.path.splitext(os.path.basename(pdf_path))[0]
+        
+        for i, df in enumerate(dfs):
+            if not df.empty:
+                csv_path = os.path.join(output_dir, f"{pdf_name}_table_{i+1}.csv")
+                df.to_csv(csv_path, index=False)
+                csv_paths.append(csv_path)
+                
+                if self.logger:
+                    self.logger.info(f"Saved table {i+1} to {csv_path}")
+                else:
+                    print(f"Saved table {i+1} to {csv_path}")
+        
+        return csv_paths

{mb_rag-1.1.23 → mb_rag-1.1.26}/mb_rag/version.py

@@ -1,5 +1,5 @@
 MAJOR_VERSION = 1
 MINOR_VERSION = 1
-PATCH_VERSION = 23
+PATCH_VERSION = 26
 version = '{}.{}.{}'.format(MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION)
 __all__  = ['MAJOR_VERSION', 'MINOR_VERSION', 'PATCH_VERSION', 'version']

{mb_rag-1.1.23 → mb_rag-1.1.26}/mb_rag.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mb_rag
-Version: 1.1.23
+Version: 1.1.26
 Summary: RAG function file
 Author: ['Malav Bateriwala']
 Requires-Python: >=3.8

{mb_rag-1.1.23 → mb_rag-1.1.26}/mb_rag.egg-info/SOURCES.txt

@@ -16,4 +16,6 @@ mb_rag/rag/__init__.py
 mb_rag/rag/embeddings.py
 mb_rag/utils/__init__.py
 mb_rag/utils/bounding_box.py
-mb_rag/utils/extra.py
+mb_rag/utils/document_extract.py
+mb_rag/utils/extra.py
+mb_rag/utils/pdf_extract.py