genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/computation/data_validator.py

@@ -0,0 +1,259 @@
+"""Data validator tool for validating data against schemas and rules."""
+
+from typing import Any, Dict, List, Optional
+import logging
+import re
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class DataValidatorTool(Tool):
+    """Validate data against schemas, patterns, and custom rules."""
+
+    def __init__(self) -> None:
+        """Initialize data validator tool."""
+        metadata = ToolMetadata(
+            name="data_validator",
+            description="Validate data types, formats, ranges, and patterns",
+            category=ToolCategory.COMPUTATION,
+            tags=["validation", "schema", "data", "rules", "constraints"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="data",
+                type="string",
+                description="Data to validate",
+                required=True,
+            ),
+            ToolParameter(
+                name="validation_type",
+                type="string",
+                description="Type of validation to perform",
+                required=True,
+                enum=[
+                    "email",
+                    "url",
+                    "phone",
+                    "ip",
+                    "date",
+                    "number",
+                    "json",
+                    "custom_regex",
+                ],
+            ),
+            ToolParameter(
+                name="custom_pattern",
+                type="string",
+                description="Custom regex pattern (for custom_regex type)",
+                required=False,
+            ),
+            ToolParameter(
+                name="min_value",
+                type="number",
+                description="Minimum value (for number validation)",
+                required=False,
+            ),
+            ToolParameter(
+                name="max_value",
+                type="number",
+                description="Maximum value (for number validation)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        data: str,
+        validation_type: str,
+        custom_pattern: Optional[str] = None,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Execute data validation.
+
+        Args:
+            data: Data to validate
+            validation_type: Type of validation
+            custom_pattern: Custom regex pattern
+            min_value: Minimum value
+            max_value: Maximum value
+
+        Returns:
+            Dictionary containing validation results
+        """
+        result: Dict[str, Any] = {
+            "validation_type": validation_type,
+            "data": data,
+            "valid": False,
+        }
+
+        try:
+            if validation_type == "email":
+                result.update(self._validate_email(data))
+            
+            elif validation_type == "url":
+                result.update(self._validate_url(data))
+            
+            elif validation_type == "phone":
+                result.update(self._validate_phone(data))
+            
+            elif validation_type == "ip":
+                result.update(self._validate_ip(data))
+            
+            elif validation_type == "date":
+                result.update(self._validate_date(data))
+            
+            elif validation_type == "number":
+                result.update(self._validate_number(data, min_value, max_value))
+            
+            elif validation_type == "custom_regex":
+                if not custom_pattern:
+                    raise ValueError("custom_pattern required for custom_regex validation")
+                result.update(self._validate_custom_regex(data, custom_pattern))
+
+            elif validation_type == "json":
+                result.update(self._validate_json(data))
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(
+            f"Data validation ({validation_type}) completed: valid={result.get('valid', False)}"
+        )
+        return result
+
+    def _validate_json(self, data: str) -> Dict[str, Any]:
+        """Validate JSON."""
+        import json
+
+        try:
+            parsed = json.loads(data)
+            return {
+                "valid": True,
+                "format": "json",
+                "parsed_type": type(parsed).__name__,
+            }
+        except Exception as e:
+            return {
+                "valid": False,
+                "format": "json",
+                "error": f"Invalid JSON: {e}",
+            }
+
+    def _validate_email(self, data: str) -> Dict[str, Any]:
+        """Validate email address."""
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        match = re.match(pattern, data)
+        return {
+            "valid": bool(match),
+            "format": "email",
+        }
+
+    def _validate_url(self, data: str) -> Dict[str, Any]:
+        """Validate URL."""
+        pattern = r'^https?://[^\s/$.?#].[^\s]*$'
+        match = re.match(pattern, data, re.IGNORECASE)
+        return {
+            "valid": bool(match),
+            "format": "url",
+        }
+
+    def _validate_phone(self, data: str) -> Dict[str, Any]:
+        """Validate phone number."""
+        # Remove common separators
+        cleaned = re.sub(r'[\s\-\(\)\.]', '', data)
+        # Check if it's all digits and reasonable length
+        valid = cleaned.isdigit() and 10 <= len(cleaned) <= 15
+        return {
+            "valid": valid,
+            "format": "phone",
+            "cleaned": cleaned if valid else None,
+        }
+
+    def _validate_ip(self, data: str) -> Dict[str, Any]:
+        """Validate IP address (IPv4)."""
+        pattern = r'^(\d{1,3}\.){3}\d{1,3}$'
+        if not re.match(pattern, data):
+            return {"valid": False, "format": "ipv4"}
+        
+        # Check each octet is 0-255
+        octets = data.split('.')
+        valid = all(0 <= int(octet) <= 255 for octet in octets)
+        
+        return {
+            "valid": valid,
+            "format": "ipv4",
+            "octets": octets if valid else None,
+        }
+
+    def _validate_date(self, data: str) -> Dict[str, Any]:
+        """Validate date format."""
+        # Common date patterns
+        patterns = [
+            (r'^\d{4}-\d{2}-\d{2}$', 'YYYY-MM-DD'),
+            (r'^\d{2}/\d{2}/\d{4}$', 'MM/DD/YYYY'),
+            (r'^\d{2}-\d{2}-\d{4}$', 'DD-MM-YYYY'),
+        ]
+        
+        for pattern, format_name in patterns:
+            if re.match(pattern, data):
+                return {
+                    "valid": True,
+                    "format": format_name,
+                }
+        
+        return {
+            "valid": False,
+            "format": "unknown",
+        }
+
+    def _validate_number(
+        self, data: str, min_value: Optional[float], max_value: Optional[float]
+    ) -> Dict[str, Any]:
+        """Validate number and range."""
+        try:
+            number = float(data)
+            
+            # Check range
+            in_range = True
+            if min_value is not None and number < min_value:
+                in_range = False
+            if max_value is not None and number > max_value:
+                in_range = False
+            
+            return {
+                "valid": in_range,
+                "format": "number",
+                "value": number,
+                "in_range": in_range,
+                "is_integer": number.is_integer(),
+            }
+        except ValueError:
+            return {
+                "valid": False,
+                "format": "number",
+                "error": "Not a valid number",
+            }
+
+    def _validate_custom_regex(self, data: str, pattern: str) -> Dict[str, Any]:
+        """Validate against custom regex pattern."""
+        try:
+            match = re.match(pattern, data)
+            return {
+                "valid": bool(match),
+                "format": "custom_regex",
+                "pattern": pattern,
+                "matched": match.group(0) if match else None,
+            }
+        except re.error as e:
+            return {
+                "valid": False,
+                "format": "custom_regex",
+                "error": f"Invalid regex pattern: {str(e)}",
+            }

genxai/tools/builtin/computation/hash_generator.py

@@ -0,0 +1,129 @@
+"""Hash generator tool for creating cryptographic hashes."""
+
+from typing import Any, Dict
+import logging
+import hashlib
+import hmac
+import base64
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class HashGeneratorTool(Tool):
+    """Generate cryptographic hashes and HMACs."""
+
+    def __init__(self) -> None:
+        """Initialize hash generator tool."""
+        metadata = ToolMetadata(
+            name="hash_generator",
+            description="Generate cryptographic hashes (MD5, SHA1, SHA256, SHA512) and HMACs",
+            category=ToolCategory.COMPUTATION,
+            tags=["hash", "crypto", "md5", "sha", "hmac", "checksum"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="data",
+                type="string",
+                description="Data to hash",
+                required=True,
+            ),
+            ToolParameter(
+                name="algorithm",
+                type="string",
+                description="Hash algorithm",
+                required=True,
+                enum=["md5", "sha1", "sha256", "sha512", "sha3_256", "sha3_512", "blake2b", "blake2s"],
+            ),
+            ToolParameter(
+                name="encoding",
+                type="string",
+                description="Input data encoding",
+                required=False,
+                default="utf-8",
+                enum=["utf-8", "ascii", "latin-1"],
+            ),
+            ToolParameter(
+                name="output_format",
+                type="string",
+                description="Output format",
+                required=False,
+                default="hex",
+                enum=["hex", "base64"],
+            ),
+            ToolParameter(
+                name="hmac_key",
+                type="string",
+                description="HMAC key (if provided, generates HMAC instead of hash)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        data: str,
+        algorithm: str,
+        encoding: str = "utf-8",
+        output_format: str = "hex",
+        hmac_key: str = None,
+    ) -> Dict[str, Any]:
+        """Execute hash generation.
+
+        Args:
+            data: Data to hash
+            algorithm: Hash algorithm
+            encoding: Input encoding
+            output_format: Output format
+            hmac_key: HMAC key (optional)
+
+        Returns:
+            Dictionary containing hash results
+        """
+        result: Dict[str, Any] = {
+            "algorithm": algorithm,
+            "output_format": output_format,
+            "success": False,
+        }
+
+        try:
+            # Encode data
+            data_bytes = data.encode(encoding)
+
+            # Generate hash or HMAC
+            if hmac_key:
+                # Generate HMAC
+                key_bytes = hmac_key.encode(encoding)
+                hash_obj = hmac.new(key_bytes, data_bytes, algorithm)
+                result["type"] = "hmac"
+            else:
+                # Generate regular hash
+                hash_obj = hashlib.new(algorithm, data_bytes)
+                result["type"] = "hash"
+
+            # Format output
+            if output_format == "hex":
+                hash_value = hash_obj.hexdigest()
+            elif output_format == "base64":
+                hash_value = base64.b64encode(hash_obj.digest()).decode("ascii")
+            else:
+                hash_value = hash_obj.hexdigest()
+
+            result.update({
+                "hash": hash_value,
+                "length": len(hash_value),
+                "input_length": len(data),
+                "success": True,
+            })
+
+        except ValueError as e:
+            result["error"] = f"Invalid algorithm: {str(e)}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Hash generation ({algorithm}) completed: success={result['success']}")
+        return result

genxai/tools/builtin/computation/regex_matcher.py

@@ -0,0 +1,201 @@
+"""Regex matcher tool for pattern matching and extraction."""
+
+from typing import Any, Dict, List, Optional
+import logging
+import re
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class RegexMatcherTool(Tool):
+    """Match, search, and extract patterns using regular expressions."""
+
+    def __init__(self) -> None:
+        """Initialize regex matcher tool."""
+        metadata = ToolMetadata(
+            name="regex_matcher",
+            description="Match, search, and extract patterns using regular expressions",
+            category=ToolCategory.COMPUTATION,
+            tags=["regex", "pattern", "matching", "extraction", "search"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="text",
+                type="string",
+                description="Text to search in",
+                required=True,
+            ),
+            ToolParameter(
+                name="pattern",
+                type="string",
+                description="Regular expression pattern",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="Operation to perform",
+                required=False,
+                default="findall",
+                enum=["match", "search", "findall", "finditer", "sub", "split"],
+            ),
+            ToolParameter(
+                name="replacement",
+                type="string",
+                description="Replacement string (for sub operation)",
+                required=False,
+            ),
+            ToolParameter(
+                name="flags",
+                type="string",
+                description="Regex flags (comma-separated: IGNORECASE,MULTILINE,DOTALL)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        text: str,
+        pattern: str,
+        operation: str = "findall",
+        replacement: Optional[str] = None,
+        flags: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute regex operation.
+
+        Args:
+            text: Text to search
+            pattern: Regex pattern
+            operation: Operation to perform
+            replacement: Replacement string
+            flags: Regex flags
+
+        Returns:
+            Dictionary containing operation results
+        """
+        result: Dict[str, Any] = {
+            "operation": operation,
+            "pattern": pattern,
+            "success": False,
+        }
+
+        try:
+            # Parse flags
+            regex_flags = self._parse_flags(flags)
+
+            # Compile pattern
+            compiled_pattern = re.compile(pattern, regex_flags)
+
+            if operation == "match":
+                match = compiled_pattern.match(text)
+                if match:
+                    result.update({
+                        "matched": True,
+                        "match": match.group(0),
+                        "groups": match.groups(),
+                        "groupdict": match.groupdict(),
+                        "span": match.span(),
+                    })
+                else:
+                    result["matched"] = False
+
+            elif operation == "search":
+                match = compiled_pattern.search(text)
+                if match:
+                    result.update({
+                        "found": True,
+                        "match": match.group(0),
+                        "groups": match.groups(),
+                        "groupdict": match.groupdict(),
+                        "span": match.span(),
+                    })
+                else:
+                    result["found"] = False
+
+            elif operation == "findall":
+                matches = compiled_pattern.findall(text)
+                result.update({
+                    "matches": matches,
+                    "count": len(matches),
+                })
+
+            elif operation == "finditer":
+                matches = []
+                for match in compiled_pattern.finditer(text):
+                    matches.append({
+                        "match": match.group(0),
+                        "groups": match.groups(),
+                        "groupdict": match.groupdict(),
+                        "span": match.span(),
+                    })
+                result.update({
+                    "matches": matches,
+                    "count": len(matches),
+                })
+
+            elif operation == "sub":
+                if replacement is None:
+                    raise ValueError("replacement parameter required for sub operation")
+                
+                new_text = compiled_pattern.sub(replacement, text)
+                result.update({
+                    "original_text": text,
+                    "new_text": new_text,
+                    "replacements_made": text != new_text,
+                })
+
+            elif operation == "split":
+                parts = compiled_pattern.split(text)
+                result.update({
+                    "parts": parts,
+                    "count": len(parts),
+                })
+
+            result["success"] = True
+
+        except re.error as e:
+            result["error"] = f"Invalid regex pattern: {str(e)}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Regex {operation} completed: success={result['success']}")
+        return result
+
+    def _parse_flags(self, flags: Optional[str]) -> int:
+        """Parse regex flags from string.
+
+        Args:
+            flags: Comma-separated flag names
+
+        Returns:
+            Combined regex flags
+        """
+        if not flags:
+            return 0
+
+        flag_map = {
+            "IGNORECASE": re.IGNORECASE,
+            "I": re.IGNORECASE,
+            "MULTILINE": re.MULTILINE,
+            "M": re.MULTILINE,
+            "DOTALL": re.DOTALL,
+            "S": re.DOTALL,
+            "VERBOSE": re.VERBOSE,
+            "X": re.VERBOSE,
+            "ASCII": re.ASCII,
+            "A": re.ASCII,
+        }
+
+        combined_flags = 0
+        for flag_name in flags.upper().split(","):
+            flag_name = flag_name.strip()
+            if flag_name in flag_map:
+                combined_flags |= flag_map[flag_name]
+
+        return combined_flags

genxai/tools/builtin/data/__init__.py

@@ -0,0 +1,15 @@
+"""Data processing tools for GenXAI."""
+
+from genxai.tools.builtin.data.json_processor import JSONProcessorTool
+from genxai.tools.builtin.data.csv_processor import CSVProcessorTool
+from genxai.tools.builtin.data.xml_processor import XMLProcessorTool
+from genxai.tools.builtin.data.data_transformer import DataTransformerTool
+from genxai.tools.builtin.data.text_analyzer import TextAnalyzerTool
+
+__all__ = [
+    "JSONProcessorTool",
+    "CSVProcessorTool",
+    "XMLProcessorTool",
+    "DataTransformerTool",
+    "TextAnalyzerTool",
+]