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

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

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

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

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

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/optional_executor.py
+
+OPTIONAL 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 OptionalExecutor(AUniversalOperationExecutor):
+    """
+    OPTIONAL operation executor - Universal operation.
+    
+    Performs optional matching (like LEFT JOIN or OPTIONAL MATCH in SPARQL).
+    Returns items whether or not the optional condition matches.
+    
+    Capability: Universal
+    Operation Type: FILTERING
+    """
+    
+    OPERATION_NAME = "OPTIONAL"
+    OPERATION_TYPE = OperationType.FILTERING
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute OPTIONAL operation."""
+        params = action.params
+        condition = params.get('condition', None)
+        path = params.get('path', None)
+        
+        node = context.node
+        result_data = self._execute_optional(node, condition, path, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'total_count': len(result_data.get('items', []))}
+        )
+    
+    def _execute_optional(self, node: Any, condition: Any, path: str, context: ExecutionContext) -> Dict:
+        """Execute OPTIONAL matching."""
+        all_items = []
+        
+        # Get data
+        if path:
+            data = node.get(path, default=[])
+        else:
+            data = node.to_native()
+        
+        # Include all items, mark which match optional condition
+        if isinstance(data, list):
+            for item in data:
+                result_item = item.copy() if isinstance(item, dict) else {'value': item}
+                result_item['_optional_matched'] = self._matches_condition(item, condition)
+                all_items.append(result_item)
+        
+        return {'items': all_items, 'count': len(all_items)}
+    
+    def _matches_condition(self, item: Any, condition: Any) -> bool:
+        """Check if item matches optional condition."""
+        if condition is None:
+            return False
+        # Simplified condition matching
+        return False
+

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

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/range_executor.py
+
+RANGE 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 RangeExecutor(AOperationExecutor):
+    """
+    RANGE operation executor - Tree/Matrix operation.
+    
+    Performs range queries on ordered data structures.
+    Optimized for TREE and MATRIX node types with efficient range scanning.
+    
+    Capability: Tree/Matrix only
+    Operation Type: FILTERING
+    """
+    
+    OPERATION_NAME = "RANGE"
+    OPERATION_TYPE = OperationType.FILTERING
+    SUPPORTED_NODE_TYPES = [NodeType.TREE, NodeType.MATRIX, NodeType.HYBRID]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute RANGE operation."""
+        params = action.params
+        start = params.get('start')
+        end = params.get('end')
+        inclusive = params.get('inclusive', True)
+        path = params.get('path', None)
+        
+        node = context.node
+        result_data = self._execute_range(node, start, end, inclusive, path, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'item_count': len(result_data.get('items', []))}
+        )
+    
+    def _execute_range(self, node: Any, start: Any, end: Any, inclusive: bool,
+                      path: str, context: ExecutionContext) -> Dict:
+        """Execute RANGE query."""
+        range_items = []
+        
+        # Get data
+        if path:
+            data = node.get(path, default={})
+        else:
+            data = node.to_native()
+        
+        # Range query (simplified - would use tree traversal in real impl)
+        if isinstance(data, dict):
+            for key, value in sorted(data.items()):
+                if inclusive:
+                    if start <= key <= end:
+                        range_items.append({key: value})
+                else:
+                    if start < key < end:
+                        range_items.append({key: value})
+        
+        return {
+            'items': range_items,
+            'count': len(range_items),
+            'range': {'start': start, 'end': end, 'inclusive': inclusive}
+        }
+

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

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/term_executor.py
+
+TERM 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 TermExecutor(AUniversalOperationExecutor):
+    """
+    TERM operation executor - Universal operation.
+    
+    Performs term-based search/matching (exact term match).
+    Used in search engines and text indexing.
+    
+    Capability: Universal
+    Operation Type: SEARCH
+    """
+    
+    OPERATION_NAME = "TERM"
+    OPERATION_TYPE = OperationType.SEARCH
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute TERM operation."""
+        params = action.params
+        field = params.get('field')
+        term = params.get('term', '')
+        path = params.get('path', None)
+        case_sensitive = params.get('case_sensitive', False)
+        
+        node = context.node
+        result_data = self._execute_term(node, field, term, path, case_sensitive, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'matched_count': len(result_data.get('items', []))}
+        )
+    
+    def _execute_term(self, node: Any, field: str, term: str, path: str, 
+                     case_sensitive: bool, context: ExecutionContext) -> Dict:
+        """Execute TERM search."""
+        matched_items = []
+        
+        # Get data
+        if path:
+            data = node.get(path, default=[])
+        else:
+            data = node.to_native()
+        
+        # Normalize term if case-insensitive
+        search_term = term if case_sensitive else term.lower()
+        
+        # Search for term
+        if isinstance(data, list):
+            for item in data:
+                value = item.get(field) if isinstance(item, dict) else str(item)
+                if value:
+                    compare_value = str(value) if case_sensitive else str(value).lower()
+                    if search_term in compare_value:
+                        matched_items.append(item)
+        
+        return {'items': matched_items, 'count': len(matched_items), 'term': term}
+

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

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/values_executor.py
+
+VALUES 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 ValuesExecutor(AUniversalOperationExecutor):
+    """
+    VALUES operation executor - Universal operation.
+    
+    Handles VALUES clause (inline data/constants).
+    Used in SQL and SPARQL for providing inline value lists.
+    
+    Capability: Universal
+    Operation Type: DATA_OPS
+    """
+    
+    OPERATION_NAME = "VALUES"
+    OPERATION_TYPE = OperationType.DATA_OPS
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute VALUES operation."""
+        params = action.params
+        values = params.get('values', [])
+        columns = params.get('columns', [])
+        
+        result_data = self._execute_values(values, columns, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'row_count': len(result_data.get('rows', []))}
+        )
+    
+    def _execute_values(self, values: List, columns: List, context: ExecutionContext) -> Dict:
+        """Execute VALUES inline data."""
+        rows = []
+        
+        # Convert values to rows with column names
+        if columns:
+            for value_row in values:
+                if isinstance(value_row, list):
+                    row = dict(zip(columns, value_row))
+                    rows.append(row)
+                elif isinstance(value_row, dict):
+                    rows.append(value_row)
+        else:
+            # No columns specified, use values as-is
+            rows = values if isinstance(values, list) else [values]
+        
+        return {
+            'rows': rows,
+            'count': len(rows),
+            'columns': columns
+        }
+

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/filtering/where_executor.py
+
+WHERE Operation 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, List, Dict
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+
+
+class WhereExecutor(AUniversalOperationExecutor):
+    """WHERE operation executor - Universal filtering operation."""
+    
+    OPERATION_NAME = "WHERE"
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute WHERE operation - filter data based on condition."""
+        condition = action.params.get('condition', '')
+        data = action.params.get('data', [])
+        
+        # Simple condition evaluation (can be enhanced with expression parser)
+        filtered = []
+        for item in data:
+            if self._evaluate_condition(item, condition):
+                filtered.append(item)
+        
+        return ExecutionResult(data=filtered, affected_count=len(filtered))
+    
+    def _evaluate_condition(self, item: Any, condition: str) -> bool:
+        """Evaluate condition on item (simplified)."""
+        # TODO: Implement full expression evaluation
+        # For now, return True (pass-through)
+        return True
+
+
+__all__ = ['WhereExecutor']

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

@@ -0,0 +1,15 @@
+"""Graph operation executors."""
+
+from .match_executor import MatchExecutor
+from .path_executor import PathExecutor
+from .out_executor import OutExecutor
+from .in_traverse_executor import InTraverseExecutor
+from .return_executor import ReturnExecutor
+
+__all__ = [
+    'MatchExecutor',
+    'PathExecutor',
+    'OutExecutor',
+    'InTraverseExecutor',
+    'ReturnExecutor',
+]

exonware/xwnode/queries/executors/graph/in_traverse_executor.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/graph/in_traverse_executor.py
+
+IN_TRAVERSE 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 AOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+class InTraverseExecutor(AOperationExecutor):
+    """
+    IN_TRAVERSE operation executor.
+    
+    Inbound graph traversal
+    
+    Capability: GRAPH, TREE, HYBRID only
+    Operation Type: GRAPH
+    """
+    
+    OPERATION_NAME = "IN_TRAVERSE"
+    OPERATION_TYPE = OperationType.GRAPH
+    SUPPORTED_NODE_TYPES = [NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute IN_TRAVERSE operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_in_traverse(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_in_traverse(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute in_traverse logic."""
+        # Implementation here
+        return {'result': 'IN_TRAVERSE executed', 'params': params}

exonware/xwnode/queries/executors/graph/match_executor.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/graph/match_executor.py
+
+MATCH 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 AOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+class MatchExecutor(AOperationExecutor):
+    """
+    MATCH operation executor.
+    
+    Graph pattern matching
+    
+    Capability: GRAPH, TREE, HYBRID only
+    Operation Type: GRAPH
+    """
+    
+    OPERATION_NAME = "MATCH"
+    OPERATION_TYPE = OperationType.GRAPH
+    SUPPORTED_NODE_TYPES = [NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute MATCH operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_match(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_match(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute match logic."""
+        # Implementation here
+        return {'result': 'MATCH executed', 'params': params}

exonware/xwnode/queries/executors/graph/out_executor.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/graph/out_executor.py
+
+OUT 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 AOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+class OutExecutor(AOperationExecutor):
+    """
+    OUT operation executor.
+    
+    Outbound graph traversal
+    
+    Capability: GRAPH, TREE, HYBRID only
+    Operation Type: GRAPH
+    """
+    
+    OPERATION_NAME = "OUT"
+    OPERATION_TYPE = OperationType.GRAPH
+    SUPPORTED_NODE_TYPES = [NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute OUT operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_out(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_out(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute out logic."""
+        # Implementation here
+        return {'result': 'OUT executed', 'params': params}