Update app.py

app.py

@@ -80,23 +80,6 @@ class MemoryTool(Tool):
         except Exception as e:
             return f"Memory error: {str(e)}"
 
-
-class LoadCsvTool(Tool):
-    name = "load_csv"
-    description = "Load and analyze CSV file. Returns summary statistics and first few rows. Input: file path."
-    inputs = {
-        "file_path": {
-            "type": "string",
-            "description": "Path to CSV file (e.g., 'data.csv' or '/app/data.csv')"
-        }
-    }
-    output_type = "string"
-
-    def forward(self, file_path: str) -> str:
-        return pd.read_csv(file_path)
-
-
-
 class WebhookPostTool(Tool):
     name = "webhook_post"
     description = "Send a JSON payload to a webhook URL and return the response as text."
@@ -142,52 +125,346 @@ class WikipediaTool(Tool):
         except Exception as e:
             return f"Wikipedia lookup failed: {e}"
 
-class WeatherTool(Tool):
-    name = "weather"
-    description = "Get current weather for a city. Input: city name."
-    inputs = {
-        "city": {
-            "type": "string",
-            "description": "The name of the city to get weather for"
-        }
-    }
-    output_type = "string"
-    
-    def forward(self, city: str) -> str:
+
+# ================================
+# PDF HANDLER CLASS
+# ================================
+class PDFHandler:
+    """Handler for PDF operations including reading PDFs with optional OCR."""
+
+    def __init__(self):
+        self.logger = logging.getLogger("PDFHandler")
+
+    def read_pdf(self, file_path: str, pages: Optional[List[int]] = None, use_ocr: bool = True, max_chars: int = DEFAULT_PDF_MAX_CHARS) -> Dict[str, Any]:
+        """Read text content from a PDF file with optional OCR fallback."""
+        self.logger.info("Reading PDF: %s | pages=%s | OCR=%s", file_path, pages, use_ocr)
+
+        if not os.path.exists(file_path):
+            return {
+                "success": False, "file": file_path, "content": "", "length": 0,
+                "error": f"File not found: {file_path}"
+            }
+
+        text = ""
         try:
-            # Geocoding to get coordinates
-            geocode_url = f"https://geocoding-api.open-meteo.com/v1/search?name={city}"
-            geo_resp = requests.get(geocode_url, timeout=10).json()
-            results = geo_resp.get("results")
-            if not results:
-                return f"Could not find coordinates for {city}."
-            lat = results[0]["latitude"]
-            lon = results[0]["longitude"]
-            
-            # Get current weather
-            weather_url = f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true"
-            weather_resp = requests.get(weather_url, timeout=10).json()
-            weather = weather_resp.get("current_weather")
-            if not weather:
-                return f"Could not retrieve weather for {city}."
-            return f"Weather in {city}: {weather['temperature']}°C, wind {weather['windspeed']} km/h, weather code {weather['weathercode']}."
+            with open(file_path, "rb") as file:
+                reader = PyPDF2.PdfReader(file)
+                total_pages = len(reader.pages)
+                page_indices = pages if pages else list(range(total_pages))
+
+                for i in page_indices:
+                    if i >= total_pages:
+                        self.logger.warning("Page %d exceeds total pages %d", i, total_pages)
+                        continue
+
+                    page = reader.pages[i]
+                    page_text = page.extract_text()
+
+                    # OCR fallback
+                    if use_ocr and (not page_text or page_text.strip() == ""):
+                        if not OCR_AVAILABLE or convert_from_path is None or pytesseract is None:
+                            return {
+                                "success": False, "file": file_path, "content": "", "length": 0,
+                                "error": "OCR requested but dependencies not installed."
+                            }
+
+                        self.logger.info("Performing OCR on page %d of %s", i, file_path)
+                        try:
+                            images = convert_from_path(file_path, first_page=i+1, last_page=i+1)
+                            if images and pytesseract is not None:
+                                page_text = pytesseract.image_to_string(images[0])
+                        except Exception as ocr_err:
+                            return {
+                                "success": False, "file": file_path, "content": "", "length": 0,
+                                "error": f"OCR failed: {ocr_err}"
+                            }
+
+                    text += page_text + "\n"
+
+            truncated_text = text[:max_chars]
+            self.logger.info("PDF read completed: %d characters extracted", len(truncated_text))
+            return {
+                "success": True, "file": file_path, "content": truncated_text, "length": len(truncated_text)
+            }
+
         except Exception as e:
-            return f"Weather lookup failed: {e}"
+            self.logger.exception("Error reading PDF: %s", file_path)
+            return {
+                "success": False, "file": file_path, "content": "", "length": 0, "error": str(e)
+            }
+
+    def merge_pdfs(self, pdf_files: List[str], output_file: str) -> Dict[str, Any]:
+        """Merge multiple PDF files into a single document."""
+        self.logger.info("Merging PDFs: %s -> %s", pdf_files, output_file)
+
+        if not pdf_files:
+            return {
+                "success": False, "output_file": output_file, "merged_count": 0,
+                "error": "No PDF files provided"
+            }
+
+        merged_count = 0
+        try:
+            merger = PyPDF2.PdfMerger()
+
+            for pdf_file in pdf_files:
+                if not os.path.exists(pdf_file):
+                    return {
+                        "success": False, "output_file": output_file, "merged_count": merged_count,
+                        "error": f"File not found: {pdf_file}"
+                    }
+
+                try:
+                    merger.append(pdf_file)
+                    merged_count += 1
+                except Exception as append_err:
+                    return {
+                        "success": False, "output_file": output_file, "merged_count": merged_count,
+                        "error": f"Failed to append {pdf_file}: {append_err}"
+                    }
+
+            os.makedirs(os.path.dirname(output_file) or ".", exist_ok=True)
+            merger.write(output_file)
+            merger.close()
+
+            self.logger.info("PDFs merged successfully: %d files -> %s", merged_count, output_file)
+            return {"success": True, "output_file": output_file, "merged_count": merged_count}
+
+        except Exception as e:
+            self.logger.exception("Error during PDF merge")
+            return {
+                "success": False, "output_file": output_file, "merged_count": merged_count, "error": str(e)
+            }
+
+    def search_pdf(self, file_path: str, keyword: str) -> Dict[str, Any]:
+        """Search for a keyword within a PDF file."""
+        self.logger.info("Searching PDF '%s' for keyword '%s'", file_path, keyword)
+
+        if not os.path.exists(file_path):
+            return {
+                "success": False, "file": file_path, "keyword": keyword, "pages": [], "found": False,
+                "error": f"File not found: {file_path}"
+            }
+
+        if not keyword or not isinstance(keyword, str):
+            return {
+                "success": False, "file": file_path, "keyword": keyword, "pages": [], "found": False,
+                "error": "Invalid keyword"
+            }
+
+        pages_found = []
+        try:
+            with open(file_path, "rb") as file:
+                reader = PyPDF2.PdfReader(file)
+                for page_num, page in enumerate(reader.pages, start=1):
+                    try:
+                        text = (page.extract_text() or "").lower()
+                        if keyword.lower() in text:
+                            pages_found.append(page_num)
+                    except Exception as page_err:
+                        self.logger.exception("Failed to read page %d", page_num)
+                        continue
+
+            found = len(pages_found) > 0
+            self.logger.info("Search completed: found=%s, pages=%s", found, pages_found)
+
+            return {
+                "success": True, "file": file_path, "keyword": keyword, "pages": pages_found, "found": found
+            }
+
+        except Exception as e:
+            self.logger.exception("Error searching PDF: %s", file_path)
+            return {
+                "success": False, "file": file_path, "keyword": keyword, "pages": [], "found": False, "error": str(e)
+            }
+
+    def pdf_to_text(self, file_path: str, output_file: Optional[str] = None) -> Dict[str, Any]:
+        """Extract text from a PDF and save to a text file."""
+        self.logger.info("Extracting text from PDF: %s", file_path)
+
+        if not os.path.exists(file_path):
+            return {
+                "success": False, "output_file": output_file or file_path.replace(".pdf", ".txt"), "length": 0,
+                "error": f"File not found: {file_path}"
+            }
+
+        if output_file is None:
+            output_file = file_path.replace(".pdf", ".txt")
+
+        try:
+            text = ""
+            with open(file_path, "rb") as file:
+                reader = PyPDF2.PdfReader(file)
+                for page_num, page in enumerate(reader.pages, start=1):
+                    try:
+                        page_text = page.extract_text() or ""
+                        text += page_text
+                    except Exception as page_err:
+                        self.logger.exception("Failed to extract text from page %d", page_num)
+                        continue
+
+            os.makedirs(os.path.dirname(output_file) or ".", exist_ok=True)
+            with open(output_file, "w", encoding="utf-8") as out_file:
+                out_file.write(text)
+
+            self.logger.info("Text extraction completed: %d characters written to %s", len(text), output_file)
+            return {"success": True, "output_file": output_file, "length": len(text)}
+
+        except Exception as e:
+            self.logger.exception("Error extracting text from PDF: %s", file_path)
+            return {
+                "success": False, "output_file": output_file, "length": 0, "error": str(e)
+            }
+
+    def generate_pdf(self, text: str, file_path: str = DEFAULT_PDF_OUTPUT, font_name: str = DEFAULT_FONT_NAME, font_size: int = DEFAULT_FONT_SIZE) -> Dict[str, Any]:
+        """Generate a PDF file from text content."""
+        self.logger.info("Generating PDF: %s", file_path)
+
+        if not REPORTLAB_AVAILABLE or not CANVAS_AVAILABLE or canvas is None:
+            return {
+                "success": False, "output_file": file_path, "length": 0,
+                "error": "ReportLab library is not installed"
+            }
+
+        try:
+            os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
+
+            c = canvas.Canvas(file_path, pagesize=A4)
+            page_width, page_height = A4
+
+            left_margin = 72
+            right_margin = 72
+            top_margin = 72
+            bottom_margin = 72
+            usable_width = int(page_width - left_margin - right_margin)
+
+            text_object = c.beginText()
+            text_object.setTextOrigin(left_margin, page_height - top_margin)
+            text_object.setFont(font_name, font_size)
+
+            for paragraph in text.split("\n"):
+                wrapped_lines = simple_split_text(paragraph, font_name, font_size, usable_width)
+
+                for line in wrapped_lines:
+                    try:
+                        text_object.textLine(line)
+                    except Exception as line_err:
+                        self.logger.exception("Failed to write line: %s", line)
+                        continue
+
+                    if text_object.getY() <= bottom_margin:
+                        c.drawText(text_object)
+                        c.showPage()
+                        text_object = c.beginText()
+                        text_object.setTextOrigin(left_margin, page_height - top_margin)
+                        text_object.setFont(font_name, font_size)
+
+            c.drawText(text_object)
+            c.save()
+
+            self.logger.info("PDF generated successfully: %s (%d characters)", file_path, len(text))
+            return {"success": True, "output_file": file_path, "length": len(text)}
+
+        except Exception as e:
+            self.logger.exception("Error generating PDF: %s", file_path)
+            return {"success": False, "output_file": file_path, "length": 0, "error": str(e)}
+
+# ================================
+# TOOL DEFINITIONS
+# ================================
+@tool
+def read_pdf_tool(file_path: str, use_ocr: bool = True) -> Dict[str, Any]:
+    """
+    Extract text from a PDF file with optional OCR fallback.
+    
+    Args:
+        file_path (str): Path to the PDF file to read
+        use_ocr (bool): Whether to use OCR for scanned PDFs when text extraction fails
+    
+    Returns:
+        Dict containing success status, file path, extracted content, and metadata
+    """
+    pdf_handler = PDFHandler()
+    return pdf_handler.read_pdf(file_path, use_ocr=use_ocr, max_chars=200000)
+
+@tool
+def merge_pdfs_tool(pdf_files: List[str], output_file: str) -> Dict[str, Any]:
+    """
+    Merge multiple PDF files into a single document.
+    
+    Args:
+        pdf_files (List[str]): List of PDF file paths to merge
+        output_file (str): Path for the merged output file
+    
+    Returns:
+        Dict containing success status, output file path, and merge metadata
+    """
+    pdf_handler = PDFHandler()
+    return pdf_handler.merge_pdfs(pdf_files, output_file)
+
+@tool
+def pdf_to_text_tool(file_path: str, output_file: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Extract text from a PDF and save to a text file.
+    
+    Args:
+        file_path (str): Path to the source PDF file
+        output_file (Optional[str]): Path for the output text file (auto-generated if None)
+    
+    Returns:
+        Dict containing success status, output file path, and text length
+    """
+    pdf_handler = PDFHandler()
+    return pdf_handler.pdf_to_text(file_path, output_file)
+
+@tool
+def search_pdf_tool(file_path: str, keyword: str) -> Dict[str, Any]:
+    """
+    Search for a keyword within a PDF file.
+    
+    Args:
+        file_path (str): Path to the PDF file to search
+        keyword (str): Keyword or phrase to search for (case-insensitive)
+    
+    Returns:
+        Dict containing success status, pages found, and search results
+    """
+    pdf_handler = PDFHandler()
+    return pdf_handler.search_pdf(file_path, keyword)
+
+@tool
+def generate_pdf_tool(text: str, file_path: str = DEFAULT_PDF_OUTPUT, font_size: int = DEFAULT_FONT_SIZE, font_name: str = DEFAULT_FONT_NAME) -> Dict[str, Any]:
+    """
+    Generate a PDF file from text content.
+    
+    Args:
+        text (str): Text content to write to the PDF
+        file_path (str): Path for the output PDF file
+        font_size (int): Font size for the text
+        font_name (str): Font name to use
+    
+    Returns:
+        Dict containing success status, output file path, and text length
+    """
+    pdf_handler = PDFHandler()
+    return pdf_handler.generate_pdf(text, file_path, font_name, font_size)
 
 # --- Initialize LLM Model ---
 model = LiteLLMModel(
     model_id="huggingface/Qwen/Qwen2.5-7B-Instruct:together",
     System_Prompt = """ 
-    You are a direct pathway to a webhook. 
+    You are a production AI agent with a direct pathway to a webhook.. Your primary focus is on processing PDF files and documents, including reading, merging, searching, converting, generating PDFs.
     Whenever the user sends a message, your first action is to send that message using the WebhookPostTool to the DEFAULT_WEBHOOK_URL. 
     Only after posting the message may you respond to the user. Handle errors gracefully.
+    You may use tools when helpful.
+    After tools run, provide a clear final answer to the user.
     """ ,
     hf_token=HF_TOKEN
 )
 
 # --- Initialize Tool-Calling Agent ---
 agent = ToolCallingAgent(
-    tools=[WebhookPostTool(), WebSearchTool(), WikipediaTool(), WeatherTool(), LoadCsvTool(), MemoryTool()],
+    tools=[WebhookPostTool(), WebSearchTool(), WikipediaTool(), MemoryTool(), merge_pdfs_tool, pdf_to_text_tool, search_pdf_tool, read_pdf_tool, generate_pdf_tool]
     model=model,
     max_steps=10,
 )