genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/file/file_reader.py

@@ -0,0 +1,102 @@
+"""File reader tool for reading file contents."""
+
+from typing import Any
+from pathlib import Path
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class FileReaderTool(Tool):
+    """Tool for reading file contents."""
+
+    def __init__(self) -> None:
+        """Initialize file reader tool."""
+        metadata = ToolMetadata(
+            name="file_reader",
+            description="Read contents from a file",
+            category=ToolCategory.FILE,
+            tags=["file", "read", "io", "text"],
+        )
+
+        parameters = [
+            ToolParameter(
+                name="path",
+                type="string",
+                description="Path to the file to read",
+            ),
+            ToolParameter(
+                name="encoding",
+                type="string",
+                description="File encoding (default: utf-8)",
+                required=False,
+                default="utf-8",
+            ),
+            ToolParameter(
+                name="max_size",
+                type="number",
+                description="Maximum file size in bytes (default: 10MB)",
+                required=False,
+                default=10 * 1024 * 1024,  # 10MB
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self, path: str, encoding: str = "utf-8", max_size: int = 10 * 1024 * 1024
+    ) -> Any:
+        """Read file contents.
+
+        Args:
+            path: File path
+            encoding: File encoding
+            max_size: Maximum file size in bytes
+
+        Returns:
+            File contents and metadata
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If file is too large
+        """
+        file_path = Path(path)
+
+        # Check if file exists
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {path}")
+
+        # Check if it's a file
+        if not file_path.is_file():
+            raise ValueError(f"Path is not a file: {path}")
+
+        # Check file size
+        file_size = file_path.stat().st_size
+        if file_size > max_size:
+            raise ValueError(
+                f"File too large: {file_size} bytes (max: {max_size} bytes)"
+            )
+
+        try:
+            # Read file contents
+            with open(file_path, "r", encoding=encoding) as f:
+                content = f.read()
+
+            logger.info(f"Read file: {path} ({file_size} bytes)")
+
+            return {
+                "path": str(file_path),
+                "content": content,
+                "size": file_size,
+                "encoding": encoding,
+                "lines": len(content.splitlines()),
+            }
+
+        except UnicodeDecodeError as e:
+            logger.error(f"Encoding error reading {path}: {e}")
+            raise ValueError(f"Failed to decode file with encoding {encoding}: {e}")
+        except Exception as e:
+            logger.error(f"Error reading file {path}: {e}")
+            raise

genxai/tools/builtin/file/file_writer.py

@@ -0,0 +1,122 @@
+"""File writer tool for writing content to files."""
+
+from typing import Any, Dict
+import logging
+import os
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class FileWriterTool(Tool):
+    """Write content to files with various encoding options."""
+
+    def __init__(self) -> None:
+        """Initialize file writer tool."""
+        metadata = ToolMetadata(
+            name="file_writer",
+            description="Write text content to files with encoding support",
+            category=ToolCategory.FILE,
+            tags=["file", "write", "io", "save", "output"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="path",
+                type="string",
+                description="Path where file should be written",
+                required=True,
+            ),
+            ToolParameter(
+                name="content",
+                type="string",
+                description="Content to write to file",
+                required=True,
+            ),
+            ToolParameter(
+                name="encoding",
+                type="string",
+                description="File encoding",
+                required=False,
+                default="utf-8",
+                enum=["utf-8", "ascii", "latin-1", "utf-16"],
+            ),
+            ToolParameter(
+                name="mode",
+                type="string",
+                description="Write mode",
+                required=False,
+                default="write",
+                enum=["write", "append"],
+            ),
+            ToolParameter(
+                name="create_dirs",
+                type="boolean",
+                description="Create parent directories if they don't exist",
+                required=False,
+                default=True,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        path: str,
+        content: str,
+        encoding: str = "utf-8",
+        mode: str = "write",
+        create_dirs: bool = True,
+    ) -> Dict[str, Any]:
+        """Execute file writing.
+
+        Args:
+            file_path: Path to write file
+            content: Content to write
+            encoding: File encoding
+            mode: Write mode (write or append)
+            create_dirs: Create directories flag
+
+        Returns:
+            Dictionary containing write results
+        """
+        result: Dict[str, Any] = {
+            "path": path,
+            "success": False,
+        }
+
+        try:
+            # Create parent directories if needed
+            if create_dirs:
+                parent_dir = os.path.dirname(path)
+                if parent_dir and not os.path.exists(parent_dir):
+                    os.makedirs(parent_dir, exist_ok=True)
+                    result["created_directories"] = True
+
+            # Determine write mode
+            write_mode = "w" if mode == "write" else "a"
+
+            # Write file
+            with open(path, write_mode, encoding=encoding) as f:
+                f.write(content)
+
+            # Get file info
+            file_size = os.path.getsize(path)
+            
+            result.update({
+                "success": True,
+                "bytes_written": len(content.encode(encoding)),
+                "file_size": file_size,
+                "encoding": encoding,
+                "mode": mode,
+            })
+
+        except PermissionError:
+            result["error"] = f"Permission denied: {path}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"File write completed: success={result['success']}")
+        return result

genxai/tools/builtin/file/image_processor.py

@@ -0,0 +1,186 @@
+"""Image processor tool for analyzing and manipulating images."""
+
+from typing import Any, Dict, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class ImageProcessorTool(Tool):
+    """Process and analyze images (resize, format conversion, metadata extraction)."""
+
+    def __init__(self) -> None:
+        """Initialize image processor tool."""
+        metadata = ToolMetadata(
+            name="image_processor",
+            description="Analyze image properties, resize, convert formats, and extract metadata",
+            category=ToolCategory.FILE,
+            tags=["image", "processing", "resize", "convert", "metadata"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="file_path",
+                type="string",
+                description="Path to image file",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="Operation to perform",
+                required=True,
+                enum=["analyze", "resize", "convert", "thumbnail"],
+            ),
+            ToolParameter(
+                name="width",
+                type="number",
+                description="Target width (for resize/thumbnail)",
+                required=False,
+            ),
+            ToolParameter(
+                name="height",
+                type="number",
+                description="Target height (for resize/thumbnail)",
+                required=False,
+            ),
+            ToolParameter(
+                name="output_format",
+                type="string",
+                description="Output format (for convert)",
+                required=False,
+                enum=["JPEG", "PNG", "GIF", "BMP", "WEBP"],
+            ),
+            ToolParameter(
+                name="output_path",
+                type="string",
+                description="Output file path (for resize/convert/thumbnail)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        file_path: str,
+        operation: str,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        output_format: Optional[str] = None,
+        output_path: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute image processing.
+
+        Args:
+            file_path: Path to image file
+            operation: Operation to perform
+            width: Target width
+            height: Target height
+            output_format: Output format
+            output_path: Output file path
+
+        Returns:
+            Dictionary containing processing results
+        """
+        try:
+            from PIL import Image
+        except ImportError:
+            raise ImportError(
+                "Pillow package not installed. Install with: pip install Pillow"
+            )
+
+        result: Dict[str, Any] = {
+            "file_path": file_path,
+            "operation": operation,
+            "success": False,
+        }
+
+        try:
+            # Open image
+            img = Image.open(file_path)
+
+            if operation == "analyze":
+                # Extract image information
+                result.update({
+                    "format": img.format,
+                    "mode": img.mode,
+                    "size": {"width": img.width, "height": img.height},
+                    "aspect_ratio": round(img.width / img.height, 2),
+                })
+
+                # Extract EXIF data if available
+                if hasattr(img, "_getexif") and img._getexif():
+                    exif_data = img._getexif()
+                    result["exif"] = {k: str(v) for k, v in exif_data.items() if v}
+
+                result["success"] = True
+
+            elif operation == "resize":
+                if not width or not height:
+                    raise ValueError("width and height required for resize operation")
+                
+                if not output_path:
+                    raise ValueError("output_path required for resize operation")
+
+                # Resize image
+                resized_img = img.resize((width, height), Image.Resampling.LANCZOS)
+                resized_img.save(output_path)
+
+                result.update({
+                    "original_size": {"width": img.width, "height": img.height},
+                    "new_size": {"width": width, "height": height},
+                    "output_path": output_path,
+                    "success": True,
+                })
+
+            elif operation == "convert":
+                if not output_format:
+                    raise ValueError("output_format required for convert operation")
+                
+                if not output_path:
+                    raise ValueError("output_path required for convert operation")
+
+                # Convert format
+                if img.mode == "RGBA" and output_format == "JPEG":
+                    # Convert RGBA to RGB for JPEG
+                    img = img.convert("RGB")
+
+                img.save(output_path, format=output_format)
+
+                result.update({
+                    "original_format": img.format,
+                    "new_format": output_format,
+                    "output_path": output_path,
+                    "success": True,
+                })
+
+            elif operation == "thumbnail":
+                if not width or not height:
+                    raise ValueError("width and height required for thumbnail operation")
+                
+                if not output_path:
+                    raise ValueError("output_path required for thumbnail operation")
+
+                # Create thumbnail (maintains aspect ratio)
+                img_copy = img.copy()
+                img_copy.thumbnail((width, height), Image.Resampling.LANCZOS)
+                img_copy.save(output_path)
+
+                result.update({
+                    "original_size": {"width": img.width, "height": img.height},
+                    "thumbnail_size": {"width": img_copy.width, "height": img_copy.height},
+                    "output_path": output_path,
+                    "success": True,
+                })
+
+        except FileNotFoundError:
+            result["error"] = f"File not found: {file_path}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Image {operation} completed: success={result['success']}")
+        return result

genxai/tools/builtin/file/pdf_parser.py

@@ -0,0 +1,144 @@
+"""PDF parser tool for extracting text and metadata from PDF files."""
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class PDFParserTool(Tool):
+    """Extract text, metadata, and structure from PDF documents."""
+
+    def __init__(self) -> None:
+        """Initialize PDF parser tool."""
+        metadata = ToolMetadata(
+            name="pdf_parser",
+            description="Extract text, metadata, and structure from PDF files",
+            category=ToolCategory.FILE,
+            tags=["pdf", "parser", "document", "extraction", "text"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="file_path",
+                type="string",
+                description="Path to PDF file",
+                required=True,
+            ),
+            ToolParameter(
+                name="extract_text",
+                type="boolean",
+                description="Whether to extract text content",
+                required=False,
+                default=True,
+            ),
+            ToolParameter(
+                name="extract_metadata",
+                type="boolean",
+                description="Whether to extract PDF metadata",
+                required=False,
+                default=True,
+            ),
+            ToolParameter(
+                name="page_range",
+                type="string",
+                description="Page range to extract (e.g., '1-5' or 'all')",
+                required=False,
+                default="all",
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        file_path: str,
+        extract_text: bool = True,
+        extract_metadata: bool = True,
+        page_range: str = "all",
+    ) -> Dict[str, Any]:
+        """Execute PDF parsing.
+
+        Args:
+            file_path: Path to PDF file
+            extract_text: Extract text flag
+            extract_metadata: Extract metadata flag
+            page_range: Page range to extract
+
+        Returns:
+            Dictionary containing extracted data
+        """
+        try:
+            import PyPDF2
+        except ImportError:
+            raise ImportError(
+                "PyPDF2 package not installed. Install with: pip install PyPDF2"
+            )
+
+        result: Dict[str, Any] = {
+            "file_path": file_path,
+            "success": False,
+        }
+
+        try:
+            with open(file_path, "rb") as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                
+                # Get page count
+                num_pages = len(pdf_reader.pages)
+                result["page_count"] = num_pages
+
+                # Extract metadata
+                if extract_metadata:
+                    metadata = pdf_reader.metadata
+                    if metadata:
+                        result["metadata"] = {
+                            "title": metadata.get("/Title", ""),
+                            "author": metadata.get("/Author", ""),
+                            "subject": metadata.get("/Subject", ""),
+                            "creator": metadata.get("/Creator", ""),
+                            "producer": metadata.get("/Producer", ""),
+                            "creation_date": str(metadata.get("/CreationDate", "")),
+                            "modification_date": str(metadata.get("/ModDate", "")),
+                        }
+
+                # Determine pages to extract
+                if page_range == "all":
+                    pages_to_extract = range(num_pages)
+                else:
+                    # Parse page range (e.g., "1-5")
+                    if "-" in page_range:
+                        start, end = page_range.split("-")
+                        pages_to_extract = range(int(start) - 1, min(int(end), num_pages))
+                    else:
+                        page_num = int(page_range) - 1
+                        pages_to_extract = [page_num] if 0 <= page_num < num_pages else []
+
+                # Extract text
+                if extract_text:
+                    pages_text = []
+                    for page_num in pages_to_extract:
+                        page = pdf_reader.pages[page_num]
+                        text = page.extract_text()
+                        pages_text.append({
+                            "page_number": page_num + 1,
+                            "text": text,
+                            "char_count": len(text),
+                        })
+                    
+                    result["pages"] = pages_text
+                    result["total_text"] = "\n\n".join([p["text"] for p in pages_text])
+                    result["extracted_pages"] = len(pages_text)
+
+                result["success"] = True
+
+        except FileNotFoundError:
+            result["error"] = f"File not found: {file_path}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"PDF parsing completed: success={result['success']}")
+        return result

genxai/tools/builtin/test/__init__.py

@@ -0,0 +1,15 @@
+"""Test tools for playground validation."""
+
+from genxai.tools.builtin.test.simple_math import SimpleMathTool
+from genxai.tools.builtin.test.string_processor import StringProcessorTool
+from genxai.tools.builtin.test.data_transformer import DataTransformerTool
+from genxai.tools.builtin.test.async_simulator import AsyncSimulatorTool
+from genxai.tools.builtin.test.error_generator import ErrorGeneratorTool
+
+__all__ = [
+    "SimpleMathTool",
+    "StringProcessorTool",
+    "DataTransformerTool",
+    "AsyncSimulatorTool",
+    "ErrorGeneratorTool",
+]

genxai/tools/builtin/test/async_simulator.py

@@ -0,0 +1,62 @@
+"""Async simulator tool for testing long-running operations and timeouts."""
+
+from typing import Any
+import asyncio
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class AsyncSimulatorTool(Tool):
+    """Tool to simulate asynchronous operations and test timeout handling."""
+
+    def __init__(self):
+        """Initialize async simulator tool."""
+        metadata = ToolMetadata(
+            name="async_simulator",
+            description="Simulate long-running async operations to test timeout and async handling",
+            category=ToolCategory.SYSTEM,
+            tags=["async", "timeout", "test", "simulator"],
+            version="1.0.0",
+            author="GenXAI",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="duration",
+                type="number",
+                description="Duration to simulate in seconds",
+                required=True,
+                min_value=0,
+                max_value=60,
+            ),
+            ToolParameter(
+                name="message",
+                type="string",
+                description="Message to return after completion",
+                required=False,
+                default="Operation completed",
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the async simulation.
+
+        Args:
+            **kwargs: Tool parameters (duration, message)
+
+        Returns:
+            Result after simulated delay
+        """
+        duration = kwargs.get("duration", 1)
+        message = kwargs.get("message", "Operation completed")
+
+        # Simulate async work
+        await asyncio.sleep(duration)
+
+        return {
+            "duration": duration,
+            "message": message,
+            "status": "completed",
+            "simulated": True,
+        }