exonware-xwnode 0.0.1.21__py3-none-any.whl → 0.0.1.23__py3-none-any.whl

exonware/xwnode/queries/executors/engine.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/engine.py
-
-Query Execution Engine
-
-This module provides the main execution engine that orchestrates operation execution
-with capability checking and routing.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, List, Dict, Optional
-from .contracts import Action, ExecutionContext, ExecutionResult, NodeType
-from .registry import get_operation_registry, OperationRegistry
-from .capability_checker import check_operation_compatibility
-from .base import UnsupportedOperationError
-from ...base import XWNodeBase
-
-
-class ExecutionEngine:
-    """
-    Main query execution engine.
-    
-    Orchestrates execution of XWQuery operations on nodes with:
-    - Capability-aware routing
-    - Operation composition
-    - Error handling
-    - Performance monitoring
-    """
-    
-    def __init__(self, registry: Optional[OperationRegistry] = None):
-        """
-        Initialize execution engine.
-        
-        Args:
-            registry: Operation registry (uses global if not provided)
-        """
-        self._registry = registry or get_operation_registry()
-        self._execution_history: List[Dict] = []
-    
-    def execute(self, query: str, node: Any, **kwargs) -> ExecutionResult:
-        """
-        Execute a query string on a node.
-        
-        Args:
-            query: XWQuery script string
-            node: Target node to execute on
-            **kwargs: Additional execution options
-            
-        Returns:
-            ExecutionResult with data
-        """
-        # Parse query to actions tree
-        from ..strategies.xwquery import XWQueryScriptStrategy
-        
-        script_strategy = XWQueryScriptStrategy()
-        parsed = script_strategy.parse_script(query)
-        actions_tree = parsed.get_actions_tree()
-        
-        # Create execution context
-        context = ExecutionContext(
-            node=node,
-            variables=kwargs.get('variables', {}),
-            options=kwargs
-        )
-        
-        # Execute actions tree
-        return self.execute_actions_tree(actions_tree, context)
-    
-    def execute_actions_tree(self, actions_tree: XWNodeBase, context: ExecutionContext) -> ExecutionResult:
-        """
-        Execute an actions tree.
-        
-        Args:
-            actions_tree: Parsed actions tree
-            context: Execution context
-            
-        Returns:
-            Combined execution result
-        """
-        tree_data = actions_tree.to_native()
-        statements = tree_data.get('root', {}).get('statements', [])
-        
-        results = []
-        
-        for statement in statements:
-            # Create action from statement
-            action = Action(
-                type=statement.get('type', 'UNKNOWN'),
-                params=statement.get('params', {}),
-                id=statement.get('id', ''),
-                line_number=statement.get('line_number', 0)
-            )
-            
-            # Execute action
-            result = self.execute_action(action, context)
-            results.append(result)
-            
-            # Store result for later actions
-            if action.id:
-                context.set_result(action.id, result.data)
-        
-        # Combine results
-        return self._combine_results(results)
-    
-    def execute_action(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """
-        Execute a single action.
-        
-        Args:
-            action: Action to execute
-            context: Execution context
-            
-        Returns:
-            ExecutionResult
-        """
-        # Get executor for this operation
-        executor = self._registry.get(action.type)
-        
-        if not executor:
-            return ExecutionResult(
-                data=None,
-                success=False,
-                error=f"No executor registered for operation: {action.type}"
-            )
-        
-        # Check capability before execution
-        try:
-            node_type = self._get_node_type(context.node)
-            
-            if not executor.can_execute_on(node_type):
-                return ExecutionResult(
-                    data=None,
-                    success=False,
-                    error=f"Operation {action.type} not supported on {node_type.name} nodes"
-                )
-            
-            # Execute
-            result = executor.execute(action, context)
-            
-            # Record execution
-            self._record_execution(action, result)
-            
-            return result
-            
-        except UnsupportedOperationError as e:
-            return ExecutionResult(
-                data=None,
-                success=False,
-                error=str(e)
-            )
-        except Exception as e:
-            return ExecutionResult(
-                data=None,
-                success=False,
-                error=f"Execution error: {str(e)}"
-            )
-    
-    def _get_node_type(self, node: Any) -> NodeType:
-        """Get node's strategy type."""
-        if hasattr(node, '_strategy') and hasattr(node._strategy, 'STRATEGY_TYPE'):
-            return node._strategy.STRATEGY_TYPE
-        elif hasattr(node, 'STRATEGY_TYPE'):
-            return node.STRATEGY_TYPE
-        return NodeType.TREE  # Default
-    
-    def _combine_results(self, results: List[ExecutionResult]) -> ExecutionResult:
-        """Combine multiple execution results."""
-        if not results:
-            return ExecutionResult(data=[])
-        
-        if len(results) == 1:
-            return results[0]
-        
-        # Combine data from all results
-        combined_data = []
-        total_affected = 0
-        total_time = 0.0
-        all_success = True
-        
-        for result in results:
-            if result.data:
-                if isinstance(result.data, list):
-                    combined_data.extend(result.data)
-                else:
-                    combined_data.append(result.data)
-            total_affected += result.affected_count
-            total_time += result.execution_time
-            all_success = all_success and result.success
-        
-        return ExecutionResult(
-            data=combined_data,
-            affected_count=total_affected,
-            execution_time=total_time,
-            success=all_success
-        )
-    
-    def _record_execution(self, action: Action, result: ExecutionResult) -> None:
-        """Record execution in history."""
-        self._execution_history.append({
-            'action': action.type,
-            'success': result.success,
-            'affected_count': result.affected_count,
-            'execution_time': result.execution_time
-        })
-    
-    def get_execution_history(self) -> List[Dict]:
-        """Get execution history."""
-        return self._execution_history.copy()
-    
-    def clear_history(self) -> None:
-        """Clear execution history."""
-        self._execution_history.clear()
-
-
-__all__ = ['ExecutionEngine']

exonware/xwnode/queries/executors/errors.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/errors.py
-
-Executor Error Classes
-
-Module-specific errors for query operation executors.
-Extends root error classes per DEV_GUIDELINES.md - no redundancy.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-# Import and REUSE root error classes per DEV_GUIDELINES
-from ...errors import (
-    XWNodeError,
-    XWNodeStrategyError,
-    XWNodeUnsupportedCapabilityError,
-    XWNodeValueError
-)
-from ...nodes.strategies.contracts import NodeType
-
-
-class ExecutorError(XWNodeStrategyError):
-    """
-    Base error for executor operations.
-    
-    Extends XWNodeStrategyError from root - follows DEV_GUIDELINES principle:
-    "Never reinvent the wheel - reuse code from xwsystem library or xnode"
-    """
-    pass
-
-
-class OperationExecutionError(ExecutorError):
-    """Raised when operation execution fails."""
-    
-    def __init__(self, operation: str, reason: str, context: dict = None):
-        message = f"Operation '{operation}' execution failed: {reason}"
-        super().__init__(message)
-        self.operation = operation
-        self.reason = reason
-        self.add_context(**(context or {}))
-
-
-class ValidationError(ExecutorError):
-    """Raised when action validation fails."""
-    
-    def __init__(self, action_type: str, reason: str):
-        message = f"Action validation failed for '{action_type}': {reason}"
-        super().__init__(message)
-        self.action_type = action_type
-        self.reason = reason
-
-
-# REUSE existing error from root, don't duplicate
-# Alias for convenience in this module
-UnsupportedOperationError = XWNodeUnsupportedCapabilityError
-
-
-__all__ = [
-    'ExecutorError',
-    'OperationExecutionError',
-    'ValidationError',
-    'UnsupportedOperationError',  # Re-exported from root
-]

exonware/xwnode/queries/executors/filtering/__init__.py

@@ -1,25 +0,0 @@
-"""Filtering operation executors."""
-
-from .where_executor import WhereExecutor
-from .filter_executor import FilterExecutor
-from .like_executor import LikeExecutor
-from .in_executor import InExecutor
-from .has_executor import HasExecutor
-from .between_executor import BetweenExecutor
-from .range_executor import RangeExecutor
-from .term_executor import TermExecutor
-from .optional_executor import OptionalExecutor
-from .values_executor import ValuesExecutor
-
-__all__ = [
-    'WhereExecutor',
-    'FilterExecutor',
-    'LikeExecutor',
-    'InExecutor',
-    'HasExecutor',
-    'BetweenExecutor',
-    'RangeExecutor',
-    'TermExecutor',
-    'OptionalExecutor',
-    'ValuesExecutor',
-]

exonware/xwnode/queries/executors/filtering/between_executor.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/between_executor.py
-
-BETWEEN Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-from ...nodes.strategies.contracts import NodeType
-
-
-class BetweenExecutor(AOperationExecutor):
-    """
-    BETWEEN operation executor - Tree/Matrix operation.
-    
-    Checks if values are within a range (inclusive).
-    Optimized for TREE and MATRIX node types.
-    
-    Capability: Tree/Matrix only
-    Operation Type: FILTERING
-    """
-    
-    OPERATION_NAME = "BETWEEN"
-    OPERATION_TYPE = OperationType.FILTERING
-    SUPPORTED_NODE_TYPES = [NodeType.TREE, NodeType.MATRIX, NodeType.HYBRID]
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute BETWEEN operation."""
-        params = action.params
-        field = params.get('field')
-        min_value = params.get('min')
-        max_value = params.get('max')
-        path = params.get('path', None)
-        
-        node = context.node
-        result_data = self._execute_between(node, field, min_value, max_value, path, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'matched_count': len(result_data.get('items', []))}
-        )
-    
-    def _execute_between(self, node: Any, field: str, min_val: Any, max_val: Any, 
-                        path: str, context: ExecutionContext) -> Dict:
-        """Execute BETWEEN range check."""
-        matched_items = []
-        
-        # Get data
-        if path:
-            data = node.get(path, default=[])
-        else:
-            data = node.to_native()
-        
-        # Check range
-        if isinstance(data, list):
-            for item in data:
-                value = item.get(field) if isinstance(item, dict) else item
-                try:
-                    if min_val <= value <= max_val:
-                        matched_items.append(item)
-                except (TypeError, ValueError):
-                    pass
-        
-        return {
-            'items': matched_items,
-            'count': len(matched_items),
-            'range': {'min': min_val, 'max': max_val}
-        }
-

exonware/xwnode/queries/executors/filtering/filter_executor.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/filter_executor.py
-
-FILTER Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List, Callable
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-
-class FilterExecutor(AUniversalOperationExecutor):
-    """
-    FILTER operation executor - Universal operation.
-    
-    Filters data based on specified conditions.
-    General-purpose filtering that works on all node types.
-    
-    Capability: Universal
-    Operation Type: FILTERING
-    """
-    
-    OPERATION_NAME = "FILTER"
-    OPERATION_TYPE = OperationType.FILTERING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute FILTER operation."""
-        params = action.params
-        condition = params.get('condition', None)
-        path = params.get('path', None)
-        
-        node = context.node
-        result_data = self._execute_filter(node, condition, path, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'filtered_count': len(result_data.get('items', []))}
-        )
-    
-    def _execute_filter(self, node: Any, condition: Any, path: str, context: ExecutionContext) -> Dict:
-        """Execute filter logic."""
-        filtered_items = []
-        
-        # Get data to filter
-        if path:
-            data = node.get(path, default=[])
-        else:
-            data = node.to_native()
-        
-        # Apply filter (simplified)
-        if isinstance(data, list):
-            for item in data:
-                if self._matches_filter(item, condition):
-                    filtered_items.append(item)
-        elif isinstance(data, dict):
-            for key, value in data.items():
-                if self._matches_filter(value, condition):
-                    filtered_items.append({key: value})
-        
-        return {'items': filtered_items, 'count': len(filtered_items)}
-    
-    def _matches_filter(self, item: Any, condition: Any) -> bool:
-        """Check if item matches filter condition."""
-        if condition is None:
-            return True
-        # Simplified condition matching
-        return True
-

exonware/xwnode/queries/executors/filtering/has_executor.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/has_executor.py
-
-HAS Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-
-class HasExecutor(AUniversalOperationExecutor):
-    """
-    HAS operation executor - Universal operation.
-    
-    Checks if a property/field exists in data.
-    
-    Capability: Universal
-    Operation Type: FILTERING
-    """
-    
-    OPERATION_NAME = "HAS"
-    OPERATION_TYPE = OperationType.FILTERING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute HAS operation."""
-        params = action.params
-        property_name = params.get('property')
-        path = params.get('path', None)
-        
-        node = context.node
-        result_data = self._execute_has(node, property_name, path, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'matched_count': len(result_data.get('items', []))}
-        )
-    
-    def _execute_has(self, node: Any, property_name: str, path: str, context: ExecutionContext) -> Dict:
-        """Execute HAS property check."""
-        matched_items = []
-        
-        # Get data
-        if path:
-            data = node.get(path, default=[])
-        else:
-            data = node.to_native()
-        
-        # Check property existence
-        if isinstance(data, list):
-            for item in data:
-                if isinstance(item, dict) and property_name in item:
-                    matched_items.append(item)
-        elif isinstance(data, dict):
-            if property_name in data:
-                matched_items.append(data)
-        
-        return {'items': matched_items, 'count': len(matched_items), 'property': property_name}
-

exonware/xwnode/queries/executors/filtering/in_executor.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/in_executor.py
-
-IN Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-
-class InExecutor(AUniversalOperationExecutor):
-    """
-    IN operation executor - Universal operation.
-    
-    Checks if a value is in a specified set.
-    
-    Capability: Universal
-    Operation Type: FILTERING
-    """
-    
-    OPERATION_NAME = "IN"
-    OPERATION_TYPE = OperationType.FILTERING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute IN operation."""
-        params = action.params
-        field = params.get('field')
-        values = params.get('values', [])
-        path = params.get('path', None)
-        
-        node = context.node
-        result_data = self._execute_in(node, field, values, path, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'matched_count': len(result_data.get('items', []))}
-        )
-    
-    def _execute_in(self, node: Any, field: str, values: List, path: str, context: ExecutionContext) -> Dict:
-        """Execute IN membership check."""
-        matched_items = []
-        values_set = set(values) if values else set()
-        
-        # Get data
-        if path:
-            data = node.get(path, default=[])
-        else:
-            data = node.to_native()
-        
-        # Check membership
-        if isinstance(data, list):
-            for item in data:
-                value = item.get(field) if isinstance(item, dict) else item
-                if value in values_set:
-                    matched_items.append(item)
-        
-        return {'items': matched_items, 'count': len(matched_items), 'values': values}
-

exonware/xwnode/queries/executors/filtering/like_executor.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/like_executor.py
-
-LIKE Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 08-Oct-2025
-"""
-
-import re
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-
-class LikeExecutor(AUniversalOperationExecutor):
-    """
-    LIKE operation executor - Universal operation.
-    
-    Pattern matching using SQL LIKE syntax (% and _ wildcards).
-    
-    Capability: Universal
-    Operation Type: FILTERING
-    """
-    
-    OPERATION_NAME = "LIKE"
-    OPERATION_TYPE = OperationType.FILTERING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute LIKE operation."""
-        params = action.params
-        field = params.get('field')
-        pattern = params.get('pattern', '')
-        path = params.get('path', None)
-        
-        node = context.node
-        result_data = self._execute_like(node, field, pattern, path, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'matched_count': len(result_data.get('items', []))}
-        )
-    
-    def _execute_like(self, node: Any, field: str, pattern: str, path: str, context: ExecutionContext) -> Dict:
-        """Execute LIKE pattern matching."""
-        matched_items = []
-        
-        # Convert SQL LIKE pattern to regex
-        # % = .* (any characters)
-        # _ = . (single character)
-        regex_pattern = pattern.replace('%', '.*').replace('_', '.')
-        regex = re.compile(regex_pattern, re.IGNORECASE)
-        
-        # Get data
-        if path:
-            data = node.get(path, default=[])
-        else:
-            data = node.to_native()
-        
-        # Match pattern
-        if isinstance(data, list):
-            for item in data:
-                value = item.get(field) if isinstance(item, dict) else str(item)
-                if value and regex.match(str(value)):
-                    matched_items.append(item)
-        
-        return {'items': matched_items, 'count': len(matched_items), 'pattern': pattern}
-