genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/data/json_processor.py

@@ -0,0 +1,233 @@
+"""JSON processor tool for parsing and manipulating JSON data."""
+
+from typing import Any, Dict, List, Optional, Union
+import logging
+import json
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class JSONProcessorTool(Tool):
+    """Process, parse, and manipulate JSON data."""
+
+    def __init__(self) -> None:
+        """Initialize JSON processor tool."""
+        metadata = ToolMetadata(
+            name="json_processor",
+            description="Parse, validate, query, and transform JSON data",
+            category=ToolCategory.DATA,
+            tags=["json", "data", "parsing", "transformation", "query"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="data",
+                type="object",
+                description="JSON input. Can be a JSON string (for parse/validate/query/etc.) or a Python object (for stringify)",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="Operation to perform",
+                required=True,
+                enum=[
+                    "parse",
+                    "validate",
+                    "query",
+                    "transform",
+                    "minify",
+                    "prettify",
+                    "stringify",
+                ],
+            ),
+            ToolParameter(
+                name="query_path",
+                type="string",
+                description="JSONPath query (for query operation)",
+                required=False,
+            ),
+            ToolParameter(
+                name="transform_rules",
+                type="object",
+                description="Transformation rules (for transform operation)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        data: Any,
+        operation: str,
+        query_path: Optional[str] = None,
+        transform_rules: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Execute JSON processing.
+
+        Args:
+            data: JSON string
+            operation: Operation to perform
+            query_path: JSONPath query
+            transform_rules: Transformation rules
+
+        Returns:
+            Dictionary containing processed data
+        """
+        result: Dict[str, Any] = {
+            "operation": operation,
+            "success": False,
+        }
+
+        try:
+            # Support passing either a JSON string (common) or a Python object
+            # for operations like "stringify".
+            if operation == "stringify":
+                # Serialize python object to JSON.
+                result["data"] = json.dumps(data)
+                result["success"] = True
+                logger.info(f"JSON {operation} operation completed: success={result['success']}")
+                return result
+
+            if not isinstance(data, str):
+                raise ValueError("data must be a JSON string for this operation")
+
+            # Parse JSON
+            parsed_data = json.loads(data)
+            result["parsed"] = True
+
+            if operation == "parse":
+                result["data"] = parsed_data
+                result["type"] = type(parsed_data).__name__
+                if isinstance(parsed_data, dict):
+                    result["keys"] = list(parsed_data.keys())
+                    result["key_count"] = len(parsed_data)
+                elif isinstance(parsed_data, list):
+                    result["length"] = len(parsed_data)
+                result["success"] = True
+
+            elif operation == "validate":
+                result["valid"] = True
+                result["data"] = parsed_data
+                result["type"] = type(parsed_data).__name__
+                result["success"] = True
+
+            elif operation == "query":
+                if not query_path:
+                    raise ValueError("query_path is required for query operation")
+                
+                # Simple JSONPath-like query implementation
+                query_result = self._query_json(parsed_data, query_path)
+                result["data"] = query_result
+                result["matches"] = len(query_result) if isinstance(query_result, list) else 1
+                result["success"] = True
+
+            elif operation == "transform":
+                if not transform_rules:
+                    raise ValueError("transform_rules is required for transform operation")
+                
+                transformed = self._transform_json(parsed_data, transform_rules)
+                result["data"] = transformed
+                result["success"] = True
+
+            elif operation == "minify":
+                minified = json.dumps(parsed_data, separators=(",", ":"))
+                result["data"] = minified
+                result["original_size"] = len(data)
+                result["minified_size"] = len(minified)
+                result["reduction_percent"] = (
+                    (len(data) - len(minified)) / len(data) * 100
+                )
+                result["success"] = True
+
+            elif operation == "prettify":
+                prettified = json.dumps(parsed_data, indent=2, sort_keys=True)
+                result["data"] = prettified
+                result["success"] = True
+
+        except json.JSONDecodeError as e:
+            result["error"] = f"Invalid JSON: {str(e)}"
+            result["error_line"] = e.lineno
+            result["error_column"] = e.colno
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"JSON {operation} operation completed: success={result['success']}")
+        return result
+
+    def _query_json(self, data: Any, path: str) -> Any:
+        """Simple JSONPath-like query implementation.
+
+        Args:
+            data: JSON data
+            path: Query path (e.g., "$.users[0].name")
+
+        Returns:
+            Query result
+        """
+        # Remove leading $. if present
+        path = path.lstrip("$.")
+        
+        parts = path.split(".")
+        current = data
+
+        for part in parts:
+            # Handle array indexing
+            if "[" in part and "]" in part:
+                key = part[:part.index("[")]
+                index_str = part[part.index("[") + 1:part.index("]")]
+                
+                if key:
+                    current = current[key]
+                
+                if index_str == "*":
+                    # Return all elements
+                    return current if isinstance(current, list) else [current]
+                else:
+                    index = int(index_str)
+                    current = current[index]
+            else:
+                current = current[part]
+
+        return current
+
+    def _transform_json(self, data: Any, rules: Dict[str, Any]) -> Any:
+        """Transform JSON data based on rules.
+
+        Args:
+            data: JSON data
+            rules: Transformation rules
+
+        Returns:
+            Transformed data
+        """
+        if not isinstance(data, dict):
+            return data
+
+        result = {}
+        
+        for new_key, rule in rules.items():
+            if isinstance(rule, str):
+                # Simple key mapping
+                if rule in data:
+                    result[new_key] = data[rule]
+            elif isinstance(rule, dict):
+                # Complex transformation
+                if "source" in rule:
+                    value = data.get(rule["source"])
+                    
+                    # Apply transformations
+                    if "uppercase" in rule and rule["uppercase"]:
+                        value = value.upper() if isinstance(value, str) else value
+                    if "lowercase" in rule and rule["lowercase"]:
+                        value = value.lower() if isinstance(value, str) else value
+                    if "default" in rule and value is None:
+                        value = rule["default"]
+                    
+                    result[new_key] = value
+
+        return result

genxai/tools/builtin/data/text_analyzer.py

@@ -0,0 +1,288 @@
+"""Text analyzer tool for analyzing and extracting insights from text."""
+
+from typing import Any, Dict, List
+import logging
+import re
+from collections import Counter
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class TextAnalyzerTool(Tool):
+    """Analyze text and extract statistics, patterns, and insights."""
+
+    def __init__(self) -> None:
+        """Initialize text analyzer tool."""
+        metadata = ToolMetadata(
+            name="text_analyzer",
+            description="Analyze text for statistics, patterns, word frequency, and readability",
+            category=ToolCategory.DATA,
+            tags=["text", "analysis", "nlp", "statistics", "patterns"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="text",
+                type="string",
+                description="Text to analyze",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="High-level analysis operation (backwards compatible with tests)",
+                required=False,
+                default="statistics",
+                enum=["word_count", "char_count", "sentiment", "statistics", "word_frequency", "patterns", "readability", "all"],
+            ),
+            ToolParameter(
+                name="top_n",
+                type="number",
+                description="Number of top items to return (for word frequency)",
+                required=False,
+                default=10,
+                min_value=1,
+                max_value=100,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        text: str,
+        operation: str = "statistics",
+        top_n: int = 10,
+    ) -> Dict[str, Any]:
+        """Execute text analysis.
+
+        Args:
+            text: Text to analyze
+            analysis_type: Type of analysis
+            top_n: Number of top items
+
+        Returns:
+            Dictionary containing analysis results
+        """
+        result: Dict[str, Any] = {
+            "operation": operation,
+            "success": False,
+        }
+
+        try:
+            # Simple operations expected by tests
+            if operation == "word_count":
+                result["word_count"] = len(text.split()) if text else 0
+                result["success"] = True
+                return result
+
+            if operation == "char_count":
+                result["char_count"] = len(text)
+                result["success"] = True
+                return result
+
+            if operation == "sentiment":
+                # Minimal / heuristic sentiment (test accepts True/False either way)
+                # This is intentionally simple to avoid heavy deps.
+                lowered = text.lower()
+                score = 0
+                for w in ["great", "good", "excellent", "love", "happy"]:
+                    if w in lowered:
+                        score += 1
+                for w in ["bad", "terrible", "hate", "sad"]:
+                    if w in lowered:
+                        score -= 1
+                result["sentiment"] = "positive" if score > 0 else "negative" if score < 0 else "neutral"
+                result["success"] = True
+                return result
+
+            # Legacy/internal richer analysis types
+            analysis_type = operation
+
+            if analysis_type == "statistics" or analysis_type == "all":
+                result["statistics"] = self._get_statistics(text)
+
+            if analysis_type == "word_frequency" or analysis_type == "all":
+                result["word_frequency"] = self._get_word_frequency(text, top_n)
+
+            if analysis_type == "patterns" or analysis_type == "all":
+                result["patterns"] = self._get_patterns(text)
+
+            if analysis_type == "readability" or analysis_type == "all":
+                result["readability"] = self._get_readability(text)
+
+            result["success"] = True
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Text analysis ({operation}) completed: success={result['success']}")
+        return result
+
+    def _get_statistics(self, text: str) -> Dict[str, Any]:
+        """Get basic text statistics.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Statistics dictionary
+        """
+        # Character counts
+        char_count = len(text)
+        char_count_no_spaces = len(text.replace(" ", ""))
+        
+        # Word counts
+        words = text.split()
+        word_count = len(words)
+        
+        # Sentence counts
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        sentence_count = len(sentences)
+        
+        # Paragraph counts
+        paragraphs = text.split('\n\n')
+        paragraphs = [p.strip() for p in paragraphs if p.strip()]
+        paragraph_count = len(paragraphs)
+        
+        # Line counts
+        lines = text.split('\n')
+        line_count = len(lines)
+        
+        # Average lengths
+        avg_word_length = char_count_no_spaces / word_count if word_count > 0 else 0
+        avg_sentence_length = word_count / sentence_count if sentence_count > 0 else 0
+        
+        return {
+            "character_count": char_count,
+            "character_count_no_spaces": char_count_no_spaces,
+            "word_count": word_count,
+            "sentence_count": sentence_count,
+            "paragraph_count": paragraph_count,
+            "line_count": line_count,
+            "average_word_length": round(avg_word_length, 2),
+            "average_sentence_length": round(avg_sentence_length, 2),
+        }
+
+    def _get_word_frequency(self, text: str, top_n: int) -> Dict[str, Any]:
+        """Get word frequency analysis.
+
+        Args:
+            text: Input text
+            top_n: Number of top words
+
+        Returns:
+            Word frequency dictionary
+        """
+        # Clean and tokenize
+        words = re.findall(r'\b\w+\b', text.lower())
+        
+        # Count frequencies
+        word_counts = Counter(words)
+        total_unique_words = len(word_counts)
+        
+        # Get top N words
+        top_words = word_counts.most_common(top_n)
+        
+        return {
+            "total_unique_words": total_unique_words,
+            "top_words": [
+                {"word": word, "count": count, "frequency": count / len(words)}
+                for word, count in top_words
+            ],
+        }
+
+    def _get_patterns(self, text: str) -> Dict[str, Any]:
+        """Get pattern analysis.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Patterns dictionary
+        """
+        # Email addresses
+        emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
+        
+        # URLs
+        urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
+        
+        # Phone numbers (simple pattern)
+        phones = re.findall(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', text)
+        
+        # Numbers
+        numbers = re.findall(r'\b\d+\.?\d*\b', text)
+        
+        # Hashtags
+        hashtags = re.findall(r'#\w+', text)
+        
+        # Mentions
+        mentions = re.findall(r'@\w+', text)
+        
+        return {
+            "emails": {"count": len(emails), "samples": emails[:5]},
+            "urls": {"count": len(urls), "samples": urls[:5]},
+            "phone_numbers": {"count": len(phones), "samples": phones[:5]},
+            "numbers": {"count": len(numbers), "samples": numbers[:10]},
+            "hashtags": {"count": len(hashtags), "samples": hashtags[:10]},
+            "mentions": {"count": len(mentions), "samples": mentions[:10]},
+        }
+
+    def _get_readability(self, text: str) -> Dict[str, Any]:
+        """Get readability metrics.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Readability dictionary
+        """
+        # Basic counts
+        words = text.split()
+        word_count = len(words)
+        
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        sentence_count = len(sentences)
+        
+        # Count syllables (simple approximation)
+        syllable_count = 0
+        for word in words:
+            word = word.lower().strip('.,!?;:')
+            syllable_count += max(1, len(re.findall(r'[aeiou]+', word)))
+        
+        # Flesch Reading Ease (approximation)
+        if sentence_count > 0 and word_count > 0:
+            avg_sentence_length = word_count / sentence_count
+            avg_syllables_per_word = syllable_count / word_count
+            flesch_score = 206.835 - 1.015 * avg_sentence_length - 84.6 * avg_syllables_per_word
+            flesch_score = max(0, min(100, flesch_score))  # Clamp between 0-100
+        else:
+            flesch_score = 0
+        
+        # Interpret score
+        if flesch_score >= 90:
+            difficulty = "Very Easy"
+        elif flesch_score >= 80:
+            difficulty = "Easy"
+        elif flesch_score >= 70:
+            difficulty = "Fairly Easy"
+        elif flesch_score >= 60:
+            difficulty = "Standard"
+        elif flesch_score >= 50:
+            difficulty = "Fairly Difficult"
+        elif flesch_score >= 30:
+            difficulty = "Difficult"
+        else:
+            difficulty = "Very Difficult"
+        
+        return {
+            "flesch_reading_ease": round(flesch_score, 2),
+            "difficulty_level": difficulty,
+            "average_sentence_length": round(word_count / sentence_count, 2) if sentence_count > 0 else 0,
+            "average_syllables_per_word": round(syllable_count / word_count, 2) if word_count > 0 else 0,
+        }

genxai/tools/builtin/data/xml_processor.py

@@ -0,0 +1,175 @@
+"""XML processor tool for parsing and manipulating XML data."""
+
+from typing import Any, Dict, List, Optional
+import logging
+import xml.etree.ElementTree as ET
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class XMLProcessorTool(Tool):
+    """Process, parse, and manipulate XML data."""
+
+    def __init__(self) -> None:
+        """Initialize XML processor tool."""
+        metadata = ToolMetadata(
+            name="xml_processor",
+            description="Parse, validate, query, and transform XML data",
+            category=ToolCategory.DATA,
+            tags=["xml", "data", "parsing", "xpath", "transformation"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="data",
+                type="string",
+                description="XML string to process",
+                required=True,
+            ),
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="Operation to perform",
+                required=True,
+                enum=["parse", "validate", "query", "to_dict", "prettify"],
+            ),
+            ToolParameter(
+                name="xpath",
+                type="string",
+                description="XPath query (for query operation)",
+                required=False,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        data: str,
+        operation: str,
+        xpath: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Execute XML processing.
+
+        Args:
+            data: XML string
+            operation: Operation to perform
+            xpath: XPath query
+
+        Returns:
+            Dictionary containing processed data
+        """
+        result: Dict[str, Any] = {
+            "operation": operation,
+            "success": False,
+        }
+
+        try:
+            # Parse XML
+            root = ET.fromstring(data)
+            result["parsed"] = True
+
+            if operation == "parse":
+                result["root_tag"] = root.tag
+                result["root_attributes"] = root.attrib
+                result["child_count"] = len(list(root))
+                result["success"] = True
+
+            elif operation == "validate":
+                # Basic validation (well-formed check)
+                result["valid"] = True
+                result["root_tag"] = root.tag
+                result["success"] = True
+
+            elif operation == "query":
+                if not xpath:
+                    raise ValueError("xpath is required for query operation")
+                
+                # Execute XPath query
+                elements = root.findall(xpath)
+                query_results = []
+                
+                for elem in elements:
+                    query_results.append({
+                        "tag": elem.tag,
+                        "text": elem.text,
+                        "attributes": elem.attrib,
+                        "children": [child.tag for child in elem],
+                    })
+                
+                result["data"] = query_results
+                result["match_count"] = len(query_results)
+                result["success"] = True
+
+            elif operation == "to_dict":
+                # Convert XML to dictionary
+                xml_dict = self._element_to_dict(root)
+                result["data"] = xml_dict
+                result["success"] = True
+
+            elif operation == "prettify":
+                # Pretty print XML
+                self._indent(root)
+                prettified = ET.tostring(root, encoding="unicode")
+                result["data"] = prettified
+                result["success"] = True
+
+        except ET.ParseError as e:
+            result["error"] = f"Invalid XML: {str(e)}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"XML {operation} operation completed: success={result['success']}")
+        return result
+
+    def _element_to_dict(self, element: ET.Element) -> Dict[str, Any]:
+        """Convert XML element to dictionary.
+
+        Args:
+            element: XML element
+
+        Returns:
+            Dictionary representation
+        """
+        result: Dict[str, Any] = {
+            "tag": element.tag,
+        }
+
+        # Add attributes
+        if element.attrib:
+            result["attributes"] = element.attrib
+
+        # Add text content
+        if element.text and element.text.strip():
+            result["text"] = element.text.strip()
+
+        # Add children
+        children = list(element)
+        if children:
+            result["children"] = [self._element_to_dict(child) for child in children]
+
+        return result
+
+    def _indent(self, elem: ET.Element, level: int = 0) -> None:
+        """Add indentation to XML element for pretty printing.
+
+        Args:
+            elem: XML element
+            level: Indentation level
+        """
+        indent = "\n" + "  " * level
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = indent + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = indent
+            for child in elem:
+                self._indent(child, level + 1)
+            if not child.tail or not child.tail.strip():
+                child.tail = indent
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = indent