exonware-xwnode 0.0.1.13__py3-none-any.whl → 0.0.1.14__py3-none-any.whl

exonware/xwnode/queries/executors/data/load_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/data/load_executor.py
+
+LOAD Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+Generation Date: 09-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+
+class LoadExecutor(AUniversalOperationExecutor):
+    """
+    LOAD operation executor.
+    
+    Loads data from external sources
+    
+    Capability: Universal
+    Operation Type: DATA_OPS
+    """
+    
+    OPERATION_NAME = "LOAD"
+    OPERATION_TYPE = OperationType.DATA_OPS
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute LOAD operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_load(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_load(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute load logic."""
+        # Implementation here
+        return {'result': 'LOAD executed', 'params': params}

exonware/xwnode/queries/executors/data/merge_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/data/merge_executor.py
+
+MERGE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+Generation Date: 09-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+
+class MergeExecutor(AUniversalOperationExecutor):
+    """
+    MERGE operation executor.
+    
+    Merges/upserts data
+    
+    Capability: Universal
+    Operation Type: DATA_OPS
+    """
+    
+    OPERATION_NAME = "MERGE"
+    OPERATION_TYPE = OperationType.DATA_OPS
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute MERGE operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_merge(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_merge(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute merge logic."""
+        # Implementation here
+        return {'result': 'MERGE executed', 'params': params}

exonware/xwnode/queries/executors/data/store_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/data/store_executor.py
+
+STORE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+Generation Date: 09-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+
+class StoreExecutor(AUniversalOperationExecutor):
+    """
+    STORE operation executor.
+    
+    Stores data to external destinations
+    
+    Capability: Universal
+    Operation Type: DATA_OPS
+    """
+    
+    OPERATION_NAME = "STORE"
+    OPERATION_TYPE = OperationType.DATA_OPS
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute STORE operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_store(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_store(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute store logic."""
+        # Implementation here
+        return {'result': 'STORE executed', 'params': params}

exonware/xwnode/queries/executors/engine.py

@@ -0,0 +1,221 @@
+#!/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.14
+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

@@ -0,0 +1,68 @@
+#!/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.14
+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

@@ -0,0 +1,25 @@
+"""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

@@ -0,0 +1,80 @@
+#!/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.14
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types 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

@@ -0,0 +1,79 @@
+#!/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.14
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List, Callable
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types 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

@@ -0,0 +1,70 @@
+#!/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.14
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types 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}
+