sonika-langchain-bot 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

sonika_langchain_bot/document_processor.py

@@ -0,0 +1,334 @@
+"""
+Document processing utilities for text extraction and chunking.
+
+This module provides tools to extract text from various document formats
+and split them into manageable chunks for processing.
+"""
+
+import tiktoken
+from typing import List, Dict, Optional
+
+
+class DocumentProcessor:
+    """
+    Service for processing documents and generating text chunks.
+    
+    Supports extraction from PDF, DOCX, TXT, XLSX, PPTX and other formats.
+    Provides intelligent text chunking with configurable overlap.
+    """
+    
+    @staticmethod
+    def count_tokens(text: str, model: str = "gpt-4") -> int:
+        """
+        Count tokens in text using tiktoken encoding.
+        
+        Args:
+            text: Text to count tokens from
+            model: Model name for encoding reference (default: "gpt-4")
+            
+        Returns:
+            int: Number of tokens in the text
+            
+        Note:
+            Falls back to character-based approximation (1 token ≈ 4 chars)
+            if tiktoken encoding fails.
+        """
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+            return len(encoding.encode(text))
+        except Exception:
+            # Fallback: approximation (1 token ≈ 4 characters)
+            return len(text) // 4
+    
+    @staticmethod
+    def extract_text_from_pdf(file_path: str) -> str:
+        """
+        Extract text content from PDF file.
+        
+        Args:
+            file_path: Path to the PDF file
+            
+        Returns:
+            str: Extracted text with page markers
+            
+        Raises:
+            Exception: If PDF extraction fails
+        """
+        try:
+            import PyPDF2
+        except ImportError:
+            raise ImportError(
+                "PyPDF2 is required for PDF processing. "
+                "Install with: pip install sonika-langchain-bot[documents]"
+            )
+        
+        text = ""
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                for page_num, page in enumerate(pdf_reader.pages):
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += f"\n--- Página {page_num + 1} ---\n{page_text}\n"
+        except Exception as e:
+            raise Exception(f"Error extracting text from PDF: {str(e)}")
+        return text.strip()
+    
+    @staticmethod
+    def extract_text_from_docx(file_path: str) -> str:
+        """
+        Extract text content from DOCX file.
+        
+        Args:
+            file_path: Path to the DOCX file
+            
+        Returns:
+            str: Extracted text
+            
+        Raises:
+            Exception: If DOCX extraction fails
+        """
+        try:
+            import docx
+        except ImportError:
+            raise ImportError(
+                "python-docx is required for DOCX processing. "
+                "Install with: pip install sonika-langchain-bot[documents]"
+            )
+        
+        try:
+            doc = docx.Document(file_path)
+            text = "\n".join([
+                paragraph.text 
+                for paragraph in doc.paragraphs 
+                if paragraph.text.strip()
+            ])
+            return text.strip()
+        except Exception as e:
+            raise Exception(f"Error extracting text from DOCX: {str(e)}")
+    
+    @staticmethod
+    def extract_text_from_txt(file_path: str) -> str:
+        """
+        Extract text content from plain text file.
+        
+        Args:
+            file_path: Path to the text file
+            
+        Returns:
+            str: File content
+            
+        Note:
+            Attempts UTF-8 encoding first, falls back to latin-1
+        """
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                return file.read().strip()
+        except UnicodeDecodeError:
+            # Fallback to latin-1 if UTF-8 fails
+            with open(file_path, 'r', encoding='latin-1') as file:
+                return file.read().strip()
+    
+    @staticmethod
+    def extract_text_from_xlsx(file_path: str) -> str:
+        """
+        Extract text content from Excel file.
+        
+        Args:
+            file_path: Path to the Excel file
+            
+        Returns:
+            str: Extracted text with sheet and row markers
+            
+        Raises:
+            Exception: If Excel extraction fails
+        """
+        try:
+            from openpyxl import load_workbook
+        except ImportError:
+            raise ImportError(
+                "openpyxl is required for Excel processing. "
+                "Install with: pip install sonika-langchain-bot[documents]"
+            )
+        
+        try:
+            workbook = load_workbook(file_path, data_only=True)
+            text = ""
+            
+            for sheet_name in workbook.sheetnames:
+                sheet = workbook[sheet_name]
+                text += f"\n--- Hoja: {sheet_name} ---\n"
+                
+                for row in sheet.iter_rows(values_only=True):
+                    row_text = " | ".join([
+                        str(cell) if cell is not None else "" 
+                        for cell in row
+                    ])
+                    if row_text.strip():
+                        text += row_text + "\n"
+            
+            return text.strip()
+        except Exception as e:
+            raise Exception(f"Error extracting text from Excel: {str(e)}")
+    
+    @staticmethod
+    def extract_text_from_pptx(file_path: str) -> str:
+        """
+        Extract text content from PowerPoint file.
+        
+        Args:
+            file_path: Path to the PowerPoint file
+            
+        Returns:
+            str: Extracted text with slide markers
+            
+        Raises:
+            Exception: If PowerPoint extraction fails
+        """
+        try:
+            from pptx import Presentation
+        except ImportError:
+            raise ImportError(
+                "python-pptx is required for PowerPoint processing. "
+                "Install with: pip install sonika-langchain-bot[documents]"
+            )
+        
+        try:
+            prs = Presentation(file_path)
+            text = ""
+            
+            for slide_num, slide in enumerate(prs.slides, 1):
+                text += f"\n--- Diapositiva {slide_num} ---\n"
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        text += shape.text + "\n"
+            
+            return text.strip()
+        except Exception as e:
+            raise Exception(f"Error extracting text from PowerPoint: {str(e)}")
+    
+    @classmethod
+    def extract_text(cls, file_path: str, file_extension: str) -> str:
+        """
+        Extract text from file based on extension.
+        
+        Args:
+            file_path: Path to the file
+            file_extension: File extension (without dot)
+            
+        Returns:
+            str: Extracted text
+            
+        Raises:
+            ValueError: If file format is not supported
+        """
+        extractors = {
+            'pdf': cls.extract_text_from_pdf,
+            'docx': cls.extract_text_from_docx,
+            'doc': cls.extract_text_from_docx,
+            'txt': cls.extract_text_from_txt,
+            'md': cls.extract_text_from_txt,
+            'xlsx': cls.extract_text_from_xlsx,
+            'xls': cls.extract_text_from_xlsx,
+            'csv': cls.extract_text_from_txt,
+            'pptx': cls.extract_text_from_pptx,
+            'ppt': cls.extract_text_from_pptx,
+        }
+        
+        extractor = extractors.get(file_extension.lower())
+        if not extractor:
+            supported = ', '.join(extractors.keys())
+            raise ValueError(
+                f"Format '{file_extension}' not supported. "
+                f"Supported formats: {supported}"
+            )
+        
+        return extractor(file_path)
+    
+    @classmethod
+    def create_chunks(
+        cls, 
+        text: str, 
+        chunk_size: int = 1000, 
+        overlap: int = 200
+    ) -> List[Dict]:
+        """
+        Split text into chunks with configurable overlap.
+        
+        Args:
+            text: Complete text to chunk
+            chunk_size: Maximum chunk size in tokens (default: 1000)
+            overlap: Token overlap between chunks (default: 200)
+            
+        Returns:
+            List[Dict]: List of chunks with metadata
+                Each chunk contains:
+                - content: Text content
+                - chunk_index: Sequential index
+                - token_count: Number of tokens
+                - metadata: Additional metadata (empty dict)
+                
+        Example:
+            >>> processor = DocumentProcessor()
+            >>> chunks = processor.create_chunks("Long text...", chunk_size=500)
+            >>> print(chunks[0])
+            {
+                'content': 'First chunk text...',
+                'chunk_index': 0,
+                'token_count': 450,
+                'metadata': {}
+            }
+        """
+        # Split into sentences (approximate)
+        sentences = text.replace('\n', ' ').split('. ')
+        
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+        chunk_index = 0
+        
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+            
+            sentence_tokens = cls.count_tokens(sentence)
+            
+            # Check if adding sentence exceeds chunk size
+            if current_tokens + sentence_tokens > chunk_size and current_chunk:
+                # Save current chunk
+                chunks.append({
+                    'content': current_chunk.strip(),
+                    'chunk_index': chunk_index,
+                    'token_count': current_tokens,
+                    'metadata': {}
+                })
+                
+                # Prepare next chunk with overlap
+                overlap_text = (
+                    ' '.join(current_chunk.split()[-overlap:]) 
+                    if overlap > 0 else ""
+                )
+                current_chunk = (
+                    overlap_text + " " + sentence 
+                    if overlap_text else sentence
+                )
+                current_tokens = cls.count_tokens(current_chunk)
+                chunk_index += 1
+            else:
+                # Add sentence to current chunk
+                current_chunk += (
+                    " " + sentence if current_chunk else sentence
+                )
+                current_tokens += sentence_tokens
+        
+        # Add last chunk if exists
+        if current_chunk.strip():
+            chunks.append({
+                'content': current_chunk.strip(),
+                'chunk_index': chunk_index,
+                'token_count': current_tokens,
+                'metadata': {}
+            })
+        
+        return chunks

sonika_langchain_bot/langchain_bot_agent.py

@@ -9,7 +9,6 @@ from langgraph.graph import StateGraph, END, add_messages
 from langgraph.prebuilt import ToolNode
 from langgraph.checkpoint.memory import MemorySaver
 from langchain_mcp_adapters.client import MultiServerMCPClient
-
 # Import your existing interfaces
 from sonika_langchain_bot.langchain_class import FileProcessorInterface, IEmbeddings, ILanguageModel, Message, ResponseModel
 
@@ -151,15 +150,24 @@ class LangChainBot:
                 tools_description += f"## {tool.name}\n"
                 tools_description += f"**Description:** {tool.description}\n\n"
                 
-                # Opción 1: Tool con args_schema explícito (tu HTTPTool)
-                if hasattr(tool, 'args_schema') and tool.args_schema:
-                    if hasattr(tool.args_schema, '__fields__'):
+                # Opción 1: args_schema es una clase Pydantic (HTTPTool)
+                if hasattr(tool, 'args_schema') and tool.args_schema and hasattr(tool.args_schema, '__fields__'):
+                    tools_description += f"**Parameters:**\n"
+                    for field_name, field_info in tool.args_schema.__fields__.items():
+                        required = "**REQUIRED**" if field_info.is_required() else "*optional*"
+                        tools_description += f"- `{field_name}` ({field_info.annotation.__name__}, {required}): {field_info.description}\n"
+                
+                # Opción 2: args_schema es un dict (MCP Tools) ← NUEVO
+                elif hasattr(tool, 'args_schema') and isinstance(tool.args_schema, dict):
+                    if 'properties' in tool.args_schema:
                         tools_description += f"**Parameters:**\n"
-                        for field_name, field_info in tool.args_schema.__fields__.items():
-                            required = "**REQUIRED**" if field_info.is_required() else "*optional*"
-                            tools_description += f"- `{field_name}` ({field_info.annotation.__name__}, {required}): {field_info.description}\n"
+                        for param_name, param_info in tool.args_schema['properties'].items():
+                            required = "**REQUIRED**" if param_name in tool.args_schema.get('required', []) else "*optional*"
+                            param_desc = param_info.get('description', 'No description')
+                            param_type = param_info.get('type', 'any')
+                            tools_description += f"- `{param_name}` ({param_type}, {required}): {param_desc}\n"
                 
-                # Opción 2: Tool básico sin args_schema (EmailTool)
+                # Opción 3: Tool básico con _run (fallback)
                 elif hasattr(tool, '_run'):
                     tools_description += f"**Parameters:**\n"
                     import inspect
@@ -170,7 +178,7 @@ class LangChainBot:
                             required = "*optional*" if param.default != inspect.Parameter.empty else "**REQUIRED**"
                             default_info = f" (default: {param.default})" if param.default != inspect.Parameter.empty else ""
                             tools_description += f"- `{param_name}` ({param_type}, {required}){default_info}\n"
-                
+                            
                 tools_description += "\n"
             
             tools_description += ("## Usage Instructions\n"
@@ -179,7 +187,7 @@ class LangChainBot:
                                 "- Do NOT call tools with empty arguments\n")
             
             instructions += tools_description
-
+        
         return instructions
 
     def _create_modern_workflow(self) -> StateGraph:
@@ -354,7 +362,10 @@ class LangChainBot:
         }
         
         # Execute the LangGraph workflow
-        result = self.graph.invoke(initial_state)
+        #result = self.graph.invoke(initial_state)
+
+         # Siempre usar ainvoke (funciona para ambos casos)
+        result = asyncio.run(self.graph.ainvoke(initial_state))
         
         # Update internal conversation history
         self.chat_history = result["messages"]

{sonika_langchain_bot-0.0.13.dist-info → sonika_langchain_bot-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonika-langchain-bot
-Version: 0.0.13
+Version: 0.0.15
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -25,6 +25,10 @@ Requires-Dist: pypdf==5.6.1
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: typing_extensions==4.14.0
 Requires-Dist: typing-inspect==0.9.0
+Requires-Dist: PyPDF2==3.0.1
+Requires-Dist: python-docx==1.2.0
+Requires-Dist: openpyxl==3.1.5
+Requires-Dist: python-pptx==1.0.2
 Provides-Extra: dev
 Requires-Dist: sphinx<9.0.0,>=8.1.3; extra == "dev"
 Requires-Dist: sphinx-rtd-theme<4.0.0,>=3.0.1; extra == "dev"

{sonika_langchain_bot-0.0.13.dist-info → sonika_langchain_bot-0.0.15.dist-info}/RECORD

@@ -1,14 +1,15 @@
 sonika_langchain_bot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonika_langchain_bot/document_processor.py,sha256=RuHT22Zt-psoe4adFWKwBJ0gi638fq8r2S5WZoDK8fY,10979
 sonika_langchain_bot/langchain_bdi.py,sha256=ithc55azP5XSPb8AGRUrDGYnVI6I4IqpqElLNat4BAQ,7024
-sonika_langchain_bot/langchain_bot_agent.py,sha256=3K8HiUzizIz7v_KmTFX9geOqiXTEwEqlm5jPXdPQeaM,23072
+sonika_langchain_bot/langchain_bot_agent.py,sha256=LlzrINl543dPwizkQ-tW47OWzud0sP18Uwb-ZhxMHeA,23968
 sonika_langchain_bot/langchain_bot_agent_bdi.py,sha256=Ev0hhRQYe6kyGAHiFDhFsfu6QnTwUFaA9oB8DfNV7u4,8613
 sonika_langchain_bot/langchain_clasificator.py,sha256=GR85ZAliymBSoDa5PXB31BvJkuiokGjS2v3RLdXnzzk,1381
 sonika_langchain_bot/langchain_class.py,sha256=5anB6v_wCzEoAJRb8fV9lPPS72E7-k51y_aeiip8RAw,1114
 sonika_langchain_bot/langchain_files.py,sha256=SEyqnJgBc_nbCIG31eypunBbO33T5AHFOhQZcghTks4,381
 sonika_langchain_bot/langchain_models.py,sha256=vqSSZ48tNofrTMLv1QugDdyey2MuIeSdlLSD37AnzkI,2235
 sonika_langchain_bot/langchain_tools.py,sha256=y7wLf1DbUua3QIvz938Ek-JIMOuQhrOIptJadW8OIsU,466
-sonika_langchain_bot-0.0.13.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.13.dist-info/METADATA,sha256=RyRtV63QD_s53I3GCCa8uuJasHU1811CoORRIYDmmuY,6380
-sonika_langchain_bot-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sonika_langchain_bot-0.0.13.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.13.dist-info/RECORD,,
+sonika_langchain_bot-0.0.15.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
+sonika_langchain_bot-0.0.15.dist-info/METADATA,sha256=TkIrUOf7OyjqybcPfdxsJkIAr_uKYPeh3cY1oVe8f4w,6508
+sonika_langchain_bot-0.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sonika_langchain_bot-0.0.15.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
+sonika_langchain_bot-0.0.15.dist-info/RECORD,,