genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/test/data_transformer.py

@@ -0,0 +1,99 @@
+"""Data transformation tool for testing JSON/data operations."""
+
+from typing import Any
+import json
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class DataTransformerTool(Tool):
+    """Tool for JSON and data transformation operations."""
+
+    def __init__(self):
+        """Initialize data transformer tool."""
+        metadata = ToolMetadata(
+            name="data_transformer",
+            description="Transform and manipulate JSON data (keys, values, filter, sort)",
+            category=ToolCategory.DATA_PROCESSING,
+            tags=["json", "data", "transform", "test"],
+            version="1.0.0",
+            author="GenXAI",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="data",
+                type="string",
+                description="JSON string to transform",
+                required=True,
+            ),
+            ToolParameter(
+                name="transformation",
+                type="string",
+                description="The transformation to apply",
+                required=True,
+                enum=["keys", "values", "count", "pretty", "minify", "reverse_keys"],
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the data transformation.
+
+        Args:
+            **kwargs: Tool parameters (data, transformation)
+
+        Returns:
+            Result of the transformation
+        """
+        data_str = kwargs.get("data", "{}")
+        transformation = kwargs.get("transformation")
+
+        try:
+            # Parse JSON
+            data = json.loads(data_str)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON: {str(e)}")
+
+        if transformation == "keys":
+            if isinstance(data, dict):
+                result = list(data.keys())
+            else:
+                raise ValueError("Data must be a JSON object for 'keys' transformation")
+        
+        elif transformation == "values":
+            if isinstance(data, dict):
+                result = list(data.values())
+            else:
+                raise ValueError("Data must be a JSON object for 'values' transformation")
+        
+        elif transformation == "count":
+            if isinstance(data, dict):
+                result = len(data)
+            elif isinstance(data, list):
+                result = len(data)
+            else:
+                result = 1
+        
+        elif transformation == "pretty":
+            result = json.dumps(data, indent=2, sort_keys=True)
+        
+        elif transformation == "minify":
+            result = json.dumps(data, separators=(',', ':'))
+        
+        elif transformation == "reverse_keys":
+            if isinstance(data, dict):
+                result = {k: v for k, v in reversed(data.items())}
+            else:
+                raise ValueError("Data must be a JSON object for 'reverse_keys' transformation")
+        
+        else:
+            raise ValueError(f"Unknown transformation: {transformation}")
+
+        return {
+            "original": data,
+            "transformation": transformation,
+            "result": result,
+            "original_type": type(data).__name__,
+            "result_type": type(result).__name__,
+        }

genxai/tools/builtin/test/error_generator.py

@@ -0,0 +1,82 @@
+"""Error generator tool for testing error handling."""
+
+from typing import Any
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class ErrorGeneratorTool(Tool):
+    """Tool to intentionally generate errors for testing error handling."""
+
+    def __init__(self):
+        """Initialize error generator tool."""
+        metadata = ToolMetadata(
+            name="error_generator",
+            description="Generate different types of errors to test error handling",
+            category=ToolCategory.SYSTEM,
+            tags=["error", "test", "validation"],
+            version="1.0.0",
+            author="GenXAI",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="error_type",
+                type="string",
+                description="Type of error to generate",
+                required=True,
+                enum=["value_error", "type_error", "zero_division", "key_error", "index_error", "none"],
+            ),
+            ToolParameter(
+                name="message",
+                type="string",
+                description="Custom error message",
+                required=False,
+                default="Test error",
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the error generation.
+
+        Args:
+            **kwargs: Tool parameters (error_type, message)
+
+        Returns:
+            Result or raises an error based on error_type
+        """
+        error_type = kwargs.get("error_type")
+        message = kwargs.get("message", "Test error")
+
+        if error_type == "value_error":
+            raise ValueError(f"ValueError: {message}")
+        
+        elif error_type == "type_error":
+            raise TypeError(f"TypeError: {message}")
+        
+        elif error_type == "zero_division":
+            # Intentionally divide by zero
+            result = 1 / 0
+            return result
+        
+        elif error_type == "key_error":
+            # Access non-existent key
+            data = {"key1": "value1"}
+            return data["non_existent_key"]
+        
+        elif error_type == "index_error":
+            # Access out of bounds index
+            data = [1, 2, 3]
+            return data[10]
+        
+        elif error_type == "none":
+            # No error, return success
+            return {
+                "status": "success",
+                "message": "No error generated",
+                "error_type": error_type,
+            }
+        
+        else:
+            raise ValueError(f"Unknown error type: {error_type}")

genxai/tools/builtin/test/simple_math.py

@@ -0,0 +1,94 @@
+"""Simple math tool for testing basic operations."""
+
+from typing import Any
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class SimpleMathTool(Tool):
+    """Tool for basic arithmetic operations."""
+
+    def __init__(self):
+        """Initialize simple math tool."""
+        metadata = ToolMetadata(
+            name="simple_math",
+            description="Perform basic arithmetic operations (add, subtract, multiply, divide)",
+            category=ToolCategory.COMPUTATION,
+            tags=["math", "arithmetic", "test"],
+            version="1.0.0",
+            author="GenXAI",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="The operation to perform",
+                required=True,
+                enum=["add", "subtract", "multiply", "divide"],
+            ),
+            ToolParameter(
+                name="a",
+                type="number",
+                description="First number",
+                required=True,
+            ),
+            ToolParameter(
+                name="b",
+                type="number",
+                description="Second number",
+                required=True,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the math operation.
+
+        Args:
+            **kwargs: Tool parameters (operation, a, b)
+
+        Returns:
+            Result of the operation
+        """
+        operation = kwargs.get("operation")
+        a = kwargs.get("a")
+        b = kwargs.get("b")
+
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                raise ValueError("Cannot divide by zero")
+            result = a / b
+        else:
+            raise ValueError(f"Unknown operation: {operation}")
+
+        return {
+            "operation": operation,
+            "a": a,
+            "b": b,
+            "result": result,
+            "formula": f"{a} {self._get_operator(operation)} {b} = {result}",
+        }
+
+    def _get_operator(self, operation: str) -> str:
+        """Get the operator symbol for an operation.
+
+        Args:
+            operation: Operation name
+
+        Returns:
+            Operator symbol
+        """
+        operators = {
+            "add": "+",
+            "subtract": "-",
+            "multiply": "×",
+            "divide": "÷",
+        }
+        return operators.get(operation, "?")

genxai/tools/builtin/test/string_processor.py

@@ -0,0 +1,72 @@
+"""String processing tool for testing string operations."""
+
+from typing import Any
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+
+class StringProcessorTool(Tool):
+    """Tool for string manipulation operations."""
+
+    def __init__(self):
+        """Initialize string processor tool."""
+        metadata = ToolMetadata(
+            name="string_processor",
+            description="Perform string manipulation operations (uppercase, lowercase, reverse, length, capitalize)",
+            category=ToolCategory.DATA_PROCESSING,
+            tags=["string", "text", "manipulation", "test"],
+            version="1.0.0",
+            author="GenXAI",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="text",
+                type="string",
+                description="The text to process",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="The operation to perform",
+                required=True,
+                enum=["uppercase", "lowercase", "reverse", "length", "capitalize", "title"],
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(self, **kwargs: Any) -> Any:
+        """Execute the string operation.
+
+        Args:
+            **kwargs: Tool parameters (text, operation)
+
+        Returns:
+            Result of the operation
+        """
+        text = kwargs.get("text", "")
+        operation = kwargs.get("operation")
+
+        if operation == "uppercase":
+            result = text.upper()
+        elif operation == "lowercase":
+            result = text.lower()
+        elif operation == "reverse":
+            result = text[::-1]
+        elif operation == "length":
+            result = len(text)
+        elif operation == "capitalize":
+            result = text.capitalize()
+        elif operation == "title":
+            result = text.title()
+        else:
+            raise ValueError(f"Unknown operation: {operation}")
+
+        return {
+            "original": text,
+            "operation": operation,
+            "result": result,
+            "original_length": len(text),
+            "result_length": len(str(result)),
+        }

genxai/tools/builtin/web/__init__.py

@@ -0,0 +1,15 @@
+"""Web tools for GenXAI."""
+
+from genxai.tools.builtin.web.web_scraper import WebScraperTool
+from genxai.tools.builtin.web.api_caller import APICallerTool
+from genxai.tools.builtin.web.url_validator import URLValidatorTool
+from genxai.tools.builtin.web.http_client import HTTPClientTool
+from genxai.tools.builtin.web.html_parser import HTMLParserTool
+
+__all__ = [
+    "WebScraperTool",
+    "APICallerTool",
+    "URLValidatorTool",
+    "HTTPClientTool",
+    "HTMLParserTool",
+]

genxai/tools/builtin/web/api_caller.py

@@ -0,0 +1,161 @@
+"""API caller tool for making HTTP requests."""
+
+from typing import Any, Dict, Optional
+import logging
+import json
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class APICallerTool(Tool):
+    """Make HTTP API calls with authentication support."""
+
+    def __init__(self) -> None:
+        """Initialize API caller tool."""
+        metadata = ToolMetadata(
+            name="api_caller",
+            description="Call external REST APIs with various HTTP methods and authentication",
+            category=ToolCategory.WEB,
+            tags=["api", "http", "rest", "request", "client"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="url",
+                type="string",
+                description="API endpoint URL",
+                required=True,
+                pattern=r"^https?://",
+            ),
+            ToolParameter(
+                name="method",
+                type="string",
+                description="HTTP method",
+                required=True,
+                enum=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+            ),
+            ToolParameter(
+                name="headers",
+                type="object",
+                description="HTTP headers as key-value pairs",
+                required=False,
+            ),
+            ToolParameter(
+                name="params",
+                type="object",
+                description="URL query parameters",
+                required=False,
+            ),
+            ToolParameter(
+                name="body",
+                type="object",
+                description="Request body (for POST, PUT, PATCH)",
+                required=False,
+            ),
+            ToolParameter(
+                name="timeout",
+                type="number",
+                description="Request timeout in seconds",
+                required=False,
+                default=30,
+                min_value=1,
+                max_value=300,
+            ),
+            ToolParameter(
+                name="follow_redirects",
+                type="boolean",
+                description="Whether to follow redirects",
+                required=False,
+                default=True,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        url: str,
+        method: str,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        timeout: int = 30,
+        follow_redirects: bool = True,
+    ) -> Dict[str, Any]:
+        """Execute API call.
+
+        Args:
+            url: API endpoint URL
+            method: HTTP method
+            headers: Request headers
+            params: Query parameters
+            body: Request body
+            timeout: Request timeout
+            follow_redirects: Follow redirects flag
+
+        Returns:
+            Dictionary containing response data
+        """
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError(
+                "httpx package not installed. Install with: pip install httpx"
+            )
+
+        # Prepare headers
+        request_headers = headers or {}
+        if body and "Content-Type" not in request_headers:
+            request_headers["Content-Type"] = "application/json"
+
+        # Prepare request
+        method = method.upper()
+        request_kwargs: Dict[str, Any] = {
+            "method": method,
+            "url": url,
+            "headers": request_headers,
+            "params": params,
+            "timeout": timeout,
+            "follow_redirects": follow_redirects,
+        }
+
+        # Add body for methods that support it
+        if method in ["POST", "PUT", "PATCH"] and body:
+            if request_headers.get("Content-Type") == "application/json":
+                request_kwargs["json"] = body
+            else:
+                request_kwargs["data"] = body
+
+        # Make request
+        async with httpx.AsyncClient() as client:
+            response = await client.request(**request_kwargs)
+
+        # Parse response
+        result: Dict[str, Any] = {
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+            "url": str(response.url),
+            "method": method,
+        }
+
+        # Try to parse JSON response
+        content_type = response.headers.get("content-type", "")
+        if "application/json" in content_type:
+            try:
+                result["data"] = response.json()
+            except json.JSONDecodeError:
+                result["data"] = response.text
+        else:
+            result["data"] = response.text
+
+        # Add response metadata
+        result["elapsed_ms"] = response.elapsed.total_seconds() * 1000
+        result["success"] = 200 <= response.status_code < 300
+
+        logger.info(
+            f"API call to {url} completed with status {response.status_code}"
+        )
+        return result