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

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

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

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

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

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

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

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

@@ -1,51 +0,0 @@
-#!/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.21
-Generation Date: 09-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 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

@@ -1,51 +0,0 @@
-#!/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.21
-Generation Date: 09-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 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

@@ -1,51 +0,0 @@
-#!/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.21
-Generation Date: 09-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 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}

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

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/graph/path_executor.py
-
-PATH Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 09-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 PathExecutor(AOperationExecutor):
-    """
-    PATH operation executor.
-    
-    Path operations in graphs
-    
-    Capability: GRAPH, TREE, HYBRID only
-    Operation Type: GRAPH
-    """
-    
-    OPERATION_NAME = "PATH"
-    OPERATION_TYPE = OperationType.GRAPH
-    SUPPORTED_NODE_TYPES = [NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID]
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute PATH operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_path(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_path(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute path logic."""
-        # Implementation here
-        return {'result': 'PATH executed', 'params': params}

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

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/graph/return_executor.py
-
-RETURN Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 09-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 ReturnExecutor(AOperationExecutor):
-    """
-    RETURN operation executor.
-    
-    Returns graph query results
-    
-    Capability: GRAPH, TREE, HYBRID only
-    Operation Type: GRAPH
-    """
-    
-    OPERATION_NAME = "RETURN"
-    OPERATION_TYPE = OperationType.GRAPH
-    SUPPORTED_NODE_TYPES = [NodeType.GRAPH, NodeType.TREE, NodeType.HYBRID]
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute RETURN operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_return(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_return(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute return logic."""
-        # Implementation here
-        return {'result': 'RETURN executed', 'params': params}

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

@@ -1,9 +0,0 @@
-"""Ordering operation executors."""
-
-from .order_executor import OrderExecutor
-from .by_executor import ByExecutor
-
-__all__ = [
-    'OrderExecutor',
-    'ByExecutor',
-]

exonware/xwnode/queries/executors/ordering/by_executor.py

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/ordering/by_executor.py
-
-BY Executor
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.21
-Generation Date: 09-Oct-2025
-"""
-
-from typing import Any, Dict, List
-from ..base import AUniversalOperationExecutor
-from ..contracts import Action, ExecutionContext, ExecutionResult
-from ..defs import OperationType
-
-class ByExecutor(AUniversalOperationExecutor):
-    """
-    BY operation executor.
-    
-    Modifier for ORDER/GROUP BY
-    
-    Capability: Universal
-    Operation Type: ORDERING
-    """
-    
-    OPERATION_NAME = "BY"
-    OPERATION_TYPE = OperationType.ORDERING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute BY operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_by(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_by(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute by logic."""
-        # Implementation here
-        return {'result': 'BY executed', 'params': params}