quantalogic 0.59.2__py3-none-any.whl → 0.60.0__py3-none-any.whl

quantalogic/tools/rag_tool/ocr_pdf_markdown.py

@@ -0,0 +1,144 @@
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+from typing import Optional, Union, List
+
+import typer
+from loguru import logger
+from pyzerox import zerox
+
+# Import the flow API (assumes quantalogic/flow/flow.py is in your project structure)
+from quantalogic.flow.flow import Nodes, Workflow
+
+class PDFToMarkdownConverter:
+    """A class to handle PDF to Markdown conversion using vision models."""
+    
+    def __init__(
+        self,
+        model: str = "gemini/gemini-2.0-flash",
+        custom_system_prompt: Optional[str] = None,
+        output_dir: Optional[str] = None
+    ):
+        self.model = model
+        self.custom_system_prompt = custom_system_prompt or (
+            "Convert the PDF page to a clean, well-formatted Markdown document. "
+            "Preserve structure, headings, and any code or mathematical notation. "
+            "For the images and chart, create a literal description what is visible. "
+            "Return only pure Markdown content, excluding any metadata or non-Markdown elements."
+        )
+        self.output_dir = output_dir
+
+    @staticmethod
+    def validate_pdf_path(pdf_path: str) -> bool:
+        """Validate the PDF file path."""
+        if not pdf_path:
+            logger.error("PDF path is required")
+            return False
+        if not os.path.exists(pdf_path):
+            logger.error(f"PDF file not found: {pdf_path}")
+            return False
+        if not pdf_path.lower().endswith(".pdf"):
+            logger.error(f"File must be a PDF: {pdf_path}")
+            return False
+        return True
+
+    async def convert_pdf(
+        self,
+        pdf_path: str,
+        select_pages: Optional[Union[int, List[int]]] = None
+    ) -> str:
+        """Convert a PDF to Markdown using a vision model."""
+        if not self.validate_pdf_path(pdf_path):
+            raise ValueError("Invalid PDF path")
+
+        try:
+            logger.info(f"Calling zerox with model: {self.model}, file: {pdf_path}")
+            zerox_result = await zerox(
+                file_path=pdf_path,
+                model=self.model,
+                system_prompt=self.custom_system_prompt,
+                output_dir=self.output_dir,
+                select_pages=select_pages
+            )
+
+            markdown_content = ""
+            if hasattr(zerox_result, 'pages') and zerox_result.pages:
+                markdown_content = "\n\n".join(
+                    page.content for page in zerox_result.pages
+                    if hasattr(page, 'content') and page.content
+                )
+            elif isinstance(zerox_result, str):
+                markdown_content = zerox_result
+            elif hasattr(zerox_result, 'markdown'):
+                markdown_content = zerox_result.markdown
+            elif hasattr(zerox_result, 'text'):
+                markdown_content = zerox_result.text
+            else:
+                markdown_content = str(zerox_result)
+                logger.warning("Unexpected zerox_result type; converted to string.")
+
+            if not markdown_content.strip():
+                logger.warning("Generated Markdown content is empty.")
+                return ""
+
+            logger.info(f"Extracted Markdown content length: {len(markdown_content)} characters")
+            return markdown_content
+
+        except Exception as e:
+            logger.error(f"Error converting PDF to Markdown: {e}")
+            raise
+
+    async def convert_and_save(
+        self,
+        pdf_path: str,
+        output_md: Optional[str] = None,
+        select_pages: Optional[Union[int, List[int]]] = None
+    ) -> str:
+        """Convert PDF to Markdown and optionally save to file."""
+        markdown_content = await self.convert_pdf(pdf_path, select_pages)
+        
+        if output_md:
+            output_path = Path(output_md)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            with output_path.open("w", encoding="utf-8") as f:
+                f.write(markdown_content)
+            logger.info(f"Saved Markdown to: {output_path}")
+            return str(output_path)
+        
+        return markdown_content
+
+# Typer CLI app
+app = typer.Typer()
+
+@app.command()
+def convert(
+    input_pdf: str = typer.Argument(..., help="Path to the input PDF file"),
+    output_md: Optional[str] = typer.Argument(None, help="Path to save the output Markdown file (defaults to input_pdf_name.md)"),
+    model: str = typer.Option("gemini/gemini-2.0-flash", help="LiteLLM-compatible model name"),
+    system_prompt: Optional[str] = typer.Option(None, help="Custom system prompt for the vision model")
+):
+    """Convert a PDF file to Markdown using vision models."""
+    if not PDFToMarkdownConverter.validate_pdf_path(input_pdf):
+        typer.echo(f"Error: Invalid PDF path: {input_pdf}", err=True)
+        raise typer.Exit(code=1)
+
+    if output_md is None:
+        output_md = str(Path(input_pdf).with_suffix(".md"))
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            converter = PDFToMarkdownConverter(
+                model=model,
+                custom_system_prompt=system_prompt,
+                output_dir=temp_dir
+            )
+            output_path = asyncio.run(converter.convert_and_save(input_pdf, output_md))
+            typer.echo(f"PDF converted to Markdown: {output_path}")
+        except Exception as e:
+            typer.echo(f"Error during conversion: {e}", err=True)
+            raise typer.Exit(code=1)
+
+if __name__ == "__main__":
+    app()

quantalogic/tools/replace_in_file_tool.py

@@ -64,7 +64,7 @@ class ReplaceInFileTool(Tool):
         "Returns the updated content or an error."
         "⚠️ THIS TOOL MUST BE USED IN PRIORITY TO UPDATE AN EXISTING FILE."
     )
-    need_validation: bool = False
+    need_validation: bool = True
 
     SIMILARITY_THRESHOLD: float = 0.85
 

quantalogic/tools/terminal_capture_tool.py

@@ -0,0 +1,293 @@
+"""Tool for capturing terminal recordings and screenshots."""
+
+import os
+import shlex
+import subprocess
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+from quantalogic.tools.execute_bash_command_tool import ExecuteBashCommandTool
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class CaptureType(str, Enum):
+    """Type of terminal capture."""
+    RECORD = "record"
+    SCREENSHOT = "screenshot"
+
+
+class TerminalCaptureTool(Tool):
+    """Tool for capturing terminal output as recordings or screenshots."""
+
+    name: str = "terminal_capture_tool"
+    description: str = "Captures terminal output as recordings or screenshots."
+    need_validation: bool = False
+    arguments: list = [
+        ToolArgument(
+            name="capture_type",
+            arg_type="string",
+            description="Type of capture ('record' or 'screenshot')",
+            required=True,
+            example="screenshot",
+        ),
+        ToolArgument(
+            name="output_path",
+            arg_type="string",
+            description="Path where to save the capture (use .cast for recordings, .png for screenshots)",
+            required=True,
+            example="/path/to/output.png",
+        ),
+        ToolArgument(
+            name="command",
+            arg_type="string",
+            description="Command to execute and capture (only for recording)",
+            required=False,
+            example="ls -la",
+        ),
+        ToolArgument(
+            name="duration",
+            arg_type="int",
+            description="Duration in seconds for recording (only for recording)",
+            required=False,
+            default="30",
+        ),
+        ToolArgument(
+            name="overwrite",
+            arg_type="boolean",
+            description="Whether to overwrite existing file",
+            required=False,
+            default="true",
+        ),
+    ]
+
+    def __init__(self):
+        """Initialize with ExecuteBashCommandTool for command execution."""
+        super().__init__()
+        self.bash_tool = ExecuteBashCommandTool()
+
+    def _ensure_dependencies(self, capture_type: CaptureType) -> bool:
+        """Check if required dependencies are installed.
+        
+        Args:
+            capture_type: Type of capture to check dependencies for
+        """
+        if capture_type == CaptureType.RECORD:
+            try:
+                # Check for asciinema using poetry run
+                result = subprocess.run(
+                    ["poetry", "run", "which", "asciinema"],
+                    capture_output=True,
+                    text=True,
+                    check=False
+                )
+                
+                if result.returncode == 0 and result.stdout:
+                    logger.info(f"Found asciinema at: {result.stdout.strip()}")
+                    return True
+
+                # If not found, try installing it
+                logger.info("Installing asciinema...")
+                install_result = subprocess.run(
+                    ["poetry", "add", "asciinema"],
+                    capture_output=True,
+                    text=True,
+                    check=False
+                )
+                
+                if install_result.returncode == 0:
+                    logger.info("Successfully installed asciinema")
+                    return True
+                    
+                logger.error(f"Failed to install asciinema: {install_result.stderr}")
+                return False
+                
+            except Exception as e:
+                logger.error(f"Error checking/installing asciinema: {e}")
+                return False
+                
+        elif capture_type == CaptureType.SCREENSHOT:
+            try:
+                # Try gnome-screenshot first
+                result = subprocess.run(
+                    ["which", "gnome-screenshot"],
+                    capture_output=True,
+                    text=True,
+                    check=False
+                )
+                
+                if result.returncode == 0:
+                    logger.info("Found gnome-screenshot")
+                    return True
+                    
+                # Try import from ImageMagick as fallback
+                result = subprocess.run(
+                    ["which", "import"],
+                    capture_output=True,
+                    text=True,
+                    check=False
+                )
+                
+                if result.returncode == 0:
+                    logger.info("Found ImageMagick import")
+                    return True
+                
+                logger.error("Neither gnome-screenshot nor ImageMagick found")
+                return False
+                
+            except Exception as e:
+                logger.error(f"Error checking screenshot dependencies: {e}")
+                return False
+
+    def _capture_screenshot(
+        self,
+        output_path: str,
+        overwrite: bool = True
+    ) -> str:
+        """Capture terminal screenshot.
+        
+        Args:
+            output_path: Path to save screenshot
+            overwrite: Whether to overwrite existing file
+        """
+        try:
+            # Ensure output directory exists
+            output_path = Path(output_path)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Check if file exists and handle overwrite
+            if output_path.exists():
+                if not overwrite:
+                    return f"File {output_path} already exists and overwrite=False"
+                try:
+                    output_path.unlink()
+                except OSError as e:
+                    return f"Failed to remove existing file: {str(e)}"
+            
+            # Get active window ID
+            window_id = subprocess.run(
+                ["xdotool", "getactivewindow"],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            if window_id.returncode != 0:
+                return "Failed to get active window ID"
+            
+            # Try gnome-screenshot first
+            if subprocess.run(["which", "gnome-screenshot"], capture_output=True).returncode == 0:
+                cmd = f"gnome-screenshot --window --file={shlex.quote(str(output_path))}"
+            else:
+                # Fallback to ImageMagick's import
+                cmd = f"import -window {window_id.stdout.strip()} {shlex.quote(str(output_path))}"
+            
+            logger.debug(f"Running command: {cmd}")
+            result = self.bash_tool.execute(command=cmd)
+            
+            if output_path.exists():
+                return f"Screenshot saved to {output_path}"
+            else:
+                return f"Failed to capture screenshot: {result}"
+                
+        except Exception as e:
+            return f"Failed to capture screenshot: {str(e)}"
+
+    def _record_terminal(
+        self, 
+        output_path: str, 
+        command: str,
+        duration: int = 30,
+        overwrite: bool = True
+    ) -> str:
+        """Record terminal session using asciinema.
+        
+        Args:
+            output_path: Path to save recording (.cast file)
+            command: Command to execute
+            duration: Recording duration in seconds
+            overwrite: Whether to overwrite existing file
+        """
+        try:
+            # Ensure output directory exists
+            output_path = Path(output_path)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Check if file exists and handle overwrite
+            if output_path.exists():
+                if not overwrite:
+                    return f"File {output_path} already exists and overwrite=False"
+                try:
+                    output_path.unlink()
+                except OSError as e:
+                    return f"Failed to remove existing file: {str(e)}"
+            
+            # Properly escape the command for shell execution
+            escaped_command = shlex.quote(command)
+            
+            # Record terminal session using poetry run to ensure correct virtualenv
+            record_cmd = (
+                f"poetry run asciinema rec -c {escaped_command} "
+                f"-t 'Terminal Recording {datetime.now()}' "
+                f"{shlex.quote(str(output_path))}"
+            )
+            logger.debug(f"Running command: {record_cmd}")
+            
+            result = self.bash_tool.execute(
+                command=record_cmd,
+                timeout=duration
+            )
+            
+            if output_path.exists():
+                return f"Recording saved to {output_path}"
+            else:
+                return f"Failed to record: {result}"
+                
+        except Exception as e:
+            return f"Failed to record terminal: {str(e)}"
+
+    def execute(
+        self,
+        capture_type: str,
+        output_path: str,
+        command: Optional[str] = None,
+        duration: Optional[int] = 30,
+        overwrite: Optional[bool] = True,
+    ) -> str:
+        """Execute the terminal capture.
+
+        Args:
+            capture_type: Type of capture ('record' or 'screenshot')
+            output_path: Path where to save the capture
+            command: Command to execute and capture (only for recording)
+            duration: Duration in seconds for recording (only for recording)
+            overwrite: Whether to overwrite existing file
+
+        Returns:
+            A string indicating success or failure
+        """
+        try:
+            capture_type_enum = CaptureType(capture_type.lower())
+        except ValueError:
+            return f"Invalid capture type: {capture_type}. Must be 'record' or 'screenshot'"
+            
+        if not self._ensure_dependencies(capture_type_enum):
+            if capture_type_enum == CaptureType.RECORD:
+                return "asciinema not found and failed to install it. Please install manually: poetry add asciinema"
+            else:
+                return "Screenshot tools not found. Please install: sudo apt install gnome-screenshot"
+            
+        if capture_type_enum == CaptureType.SCREENSHOT:
+            return self._capture_screenshot(output_path, overwrite)
+        else:
+            if not command:
+                return "Command is required for recording"
+            return self._record_terminal(output_path, command, duration, overwrite)
+
+
+if __name__ == "__main__":
+    tool = TerminalCaptureTool()
+    print(tool.to_markdown())

quantalogic/tools/tool.py

@@ -58,6 +58,10 @@ class ToolDefinition(BaseModel):
         default=False,
         description="When True, requires user confirmation before execution. Useful for tools that perform potentially destructive operations.",
     )
+    need_post_process: bool = Field(
+        default=True,
+        description="When True, requires user confirmation before execution. Useful for tools that perform potentially destructive operations.",
+    )
     need_variables: bool = Field(
         default=False,
         description="When True, provides access to the agent's variable store. Required for tools that need to interpolate variables (e.g., Jinja templates).",

quantalogic/tools/utilities/__init__.py

@@ -11,6 +11,7 @@ from .csv_processor_tool import CSVProcessorTool
 from .download_file_tool import PrepareDownloadTool
 from .mermaid_validator_tool import MermaidValidatorTool
 from .vscode_tool import VSCodeServerTool
+from .llm_tool import OrientedLLMTool
 
 # Define __all__ to control what is imported with `from ... import *`
 __all__ = [
@@ -18,6 +19,7 @@ __all__ = [
     'PrepareDownloadTool',
     'MermaidValidatorTool',
     'VSCodeServerTool',
+    'OrientedLLMTool',
 ]
 
 # Optional: Add logging for import confirmation

quantalogic/tools/utilities/download_file_tool.py

@@ -20,7 +20,7 @@ class PrepareDownloadTool(Tool):
         "If it's a directory, it will be zipped. "
         "Returns an HTML link for downloading."
     )
-    need_validation: bool = True
+    need_validation: bool = False
     arguments: list = [
         ToolArgument(
             name="path",
@@ -106,10 +106,8 @@ class PrepareDownloadTool(Tool):
         )
         
         # Create the HTML link with embedded styles
-        html = f'''<a href="{url}" 
-            style="{style}" 
-            onmouseover="this.style.backgroundColor='#0066cc'; this.style.color='white';" 
-            onmouseout="this.style.backgroundColor='transparent'; this.style.color='#0066cc';" 
+        html = f'''Using this download functionnal download link : <a href="{url}" 
+            style="{style}"  
             download="{filename}">{text}</a>'''
             
         return html