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

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

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

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

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

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

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

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

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/ordering/order_executor.py
+
+ORDER Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+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 OrderExecutor(AOperationExecutor):
+    """
+    ORDER operation executor.
+    
+    Orders/sorts data
+    
+    Capability: TREE, LINEAR only
+    Operation Type: ORDERING
+    """
+    
+    OPERATION_NAME = "ORDER"
+    OPERATION_TYPE = OperationType.ORDERING
+    SUPPORTED_NODE_TYPES = [NodeType.TREE, NodeType.LINEAR]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute ORDER operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_order(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_order(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute order logic."""
+        # Implementation here
+        return {'result': 'ORDER executed', 'params': params}

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

@@ -0,0 +1,9 @@
+"""Projection operation executors."""
+
+from .project_executor import ProjectExecutor
+from .extend_executor import ExtendExecutor
+
+__all__ = [
+    'ProjectExecutor',
+    'ExtendExecutor',
+]

exonware/xwnode/queries/executors/projection/extend_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/projection/extend_executor.py
+
+EXTEND Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+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 ExtendExecutor(AUniversalOperationExecutor):
+    """
+    EXTEND operation executor.
+    
+    Extends data with computed fields
+    
+    Capability: Universal
+    Operation Type: PROJECTION
+    """
+    
+    OPERATION_NAME = "EXTEND"
+    OPERATION_TYPE = OperationType.PROJECTION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute EXTEND operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_extend(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_extend(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute extend logic."""
+        # Implementation here
+        return {'result': 'EXTEND executed', 'params': params}

exonware/xwnode/queries/executors/projection/project_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/projection/project_executor.py
+
+PROJECT Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+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 ProjectExecutor(AUniversalOperationExecutor):
+    """
+    PROJECT operation executor.
+    
+    Projects/selects specific fields
+    
+    Capability: Universal
+    Operation Type: PROJECTION
+    """
+    
+    OPERATION_NAME = "PROJECT"
+    OPERATION_TYPE = OperationType.PROJECTION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute PROJECT operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_project(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_project(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute project logic."""
+        # Implementation here
+        return {'result': 'PROJECT executed', 'params': params}

exonware/xwnode/queries/executors/registry.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/registry.py
+
+Operation Executor Registry
+
+This module provides registry for managing operation executors.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+import threading
+from typing import Dict, Type, Optional, List
+
+from .contracts import IOperationExecutor, NodeType
+from ...errors import XWNodeValueError
+
+
+class OperationRegistry:
+    """
+    Registry for operation executors.
+    
+    Manages registration and retrieval of executors for the 50 XWQuery operations.
+    Thread-safe implementation with singleton pattern.
+    """
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        """Ensure singleton instance."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        """Initialize the registry."""
+        if self._initialized:
+            return
+        
+        self._executors: Dict[str, Type[IOperationExecutor]] = {}
+        self._instances: Dict[str, IOperationExecutor] = {}
+        self._lock = threading.RLock()
+        self._initialized = True
+    
+    def register(self, operation_name: str, executor_class: Type[IOperationExecutor]) -> None:
+        """
+        Register an executor for an operation.
+        
+        Args:
+            operation_name: Name of operation (e.g., "SELECT")
+            executor_class: Executor class
+        """
+        with self._lock:
+            self._executors[operation_name.upper()] = executor_class
+    
+    def get(self, operation_name: str) -> Optional[IOperationExecutor]:
+        """
+        Get executor instance for an operation.
+        
+        Args:
+            operation_name: Name of operation
+            
+        Returns:
+            Executor instance or None if not found
+        """
+        operation_name = operation_name.upper()
+        
+        with self._lock:
+            # Return cached instance if exists
+            if operation_name in self._instances:
+                return self._instances[operation_name]
+            
+            # Create new instance
+            if operation_name in self._executors:
+                executor_class = self._executors[operation_name]
+                instance = executor_class()
+                self._instances[operation_name] = instance
+                return instance
+        
+        return None
+    
+    def has(self, operation_name: str) -> bool:
+        """
+        Check if operation is registered.
+        
+        Args:
+            operation_name: Name of operation
+            
+        Returns:
+            True if operation is registered
+        """
+        return operation_name.upper() in self._executors
+    
+    def list_operations(self) -> List[str]:
+        """Get list of all registered operations."""
+        with self._lock:
+            return list(self._executors.keys())
+    
+    def list_operations_for_node_type(self, node_type: NodeType) -> List[str]:
+        """
+        Get list of operations supported by a node type.
+        
+        Args:
+            node_type: Node type to check
+            
+        Returns:
+            List of operation names
+        """
+        operations = []
+        
+        with self._lock:
+            for op_name, executor_class in self._executors.items():
+                # Instantiate temporarily to check
+                executor = executor_class()
+                if executor.can_execute_on(node_type):
+                    operations.append(op_name)
+        
+        return operations
+    
+    def clear(self) -> None:
+        """Clear all registrations (for testing)."""
+        with self._lock:
+            self._executors.clear()
+            self._instances.clear()
+
+
+# Global registry instance
+_global_registry: Optional[OperationRegistry] = None
+_global_lock = threading.Lock()
+
+
+def get_operation_registry() -> OperationRegistry:
+    """Get the global operation registry instance."""
+    global _global_registry
+    
+    if _global_registry is None:
+        with _global_lock:
+            if _global_registry is None:
+                _global_registry = OperationRegistry()
+    
+    return _global_registry
+
+
+def register_operation(operation_name: str):
+    """
+    Decorator to register an operation executor.
+    
+    Usage:
+        @register_operation("CUSTOM_OP")
+        class CustomOperationExecutor(AOperationExecutor):
+            ...
+    """
+    def decorator(executor_class: Type[IOperationExecutor]):
+        registry = get_operation_registry()
+        registry.register(operation_name, executor_class)
+        return executor_class
+    return decorator
+
+
+__all__ = [
+    'OperationRegistry',
+    'get_operation_registry',
+    'register_operation',
+    'UnsupportedOperationError',
+]

exonware/xwnode/queries/executors/types.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/types.py
+
+Executor Types and Enums
+
+Module-specific types for query operation executors.
+Imports shared types from root types.py per DEV_GUIDELINES.md.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from enum import Enum, Flag, auto
+
+# Import shared types from root
+from ...types import QueryMode, QueryTrait
+
+# Import node type from nodes module
+from ...nodes.strategies.contracts import NodeType
+
+
+class OperationType(Enum):
+    """
+    Operation category classification.
+    
+    Used to group the 50 operations by their primary purpose.
+    """
+    CORE = auto()           # SELECT, INSERT, UPDATE, DELETE, CREATE, DROP
+    FILTERING = auto()      # WHERE, FILTER, BETWEEN, LIKE, IN, HAS
+    AGGREGATION = auto()    # GROUP BY, HAVING, SUM, AVG, COUNT, MIN, MAX, DISTINCT
+    ORDERING = auto()       # ORDER BY, LIMIT, OFFSET
+    JOINING = auto()        # JOIN, UNION, WITH, OPTIONAL
+    GRAPH = auto()          # MATCH, PATH, OUT, IN_TRAVERSE, RETURN
+    PROJECTION = auto()     # PROJECT, EXTEND, CONSTRUCT
+    SEARCH = auto()         # TERM, RANGE
+    DATA_OPS = auto()       # LOAD, STORE, MERGE, ALTER, DESCRIBE
+    CONTROL_FLOW = auto()   # FOREACH, LET, FOR
+    WINDOW = auto()         # WINDOW, AGGREGATE
+    ARRAY = auto()          # SLICING, INDEXING
+    ADVANCED = auto()       # ASK, SUBSCRIBE, MUTATION, PIPE, OPTIONS, VALUES
+
+
+class ExecutionStatus(Enum):
+    """
+    Execution status for operations.
+    """
+    PENDING = auto()        # Not yet started
+    VALIDATING = auto()     # Validating action
+    EXECUTING = auto()      # Currently executing
+    COMPLETED = auto()      # Successfully completed
+    FAILED = auto()         # Execution failed
+    CANCELLED = auto()      # Execution cancelled
+
+
+class OperationCapability(Flag):
+    """
+    Operation capability flags.
+    
+    Defines what capabilities an operation requires to execute.
+    Moved from contracts.py per DEV_GUIDELINES.md (enums in types.py).
+    """
+    NONE = 0
+    
+    # Node type requirements
+    REQUIRES_LINEAR = auto()
+    REQUIRES_TREE = auto()
+    REQUIRES_GRAPH = auto()
+    REQUIRES_MATRIX = auto()
+    
+    # Trait requirements
+    REQUIRES_ORDERED = auto()
+    REQUIRES_INDEXED = auto()
+    REQUIRES_HIERARCHICAL = auto()
+    REQUIRES_WEIGHTED = auto()
+    REQUIRES_SPATIAL = auto()
+    
+    # Special requirements
+    REQUIRES_MUTABLE = auto()
+    REQUIRES_TRANSACTIONAL = auto()
+
+
+__all__ = [
+    'OperationType',
+    'ExecutionStatus',
+    'OperationCapability',
+    'NodeType',  # Re-export for convenience
+    'QueryMode',  # Re-export from root
+    'QueryTrait',  # Re-export from root
+]

exonware/xwnode/queries/parsers/__init__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/parsers/__init__.py
+
+Query Parsers Module
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 09-Oct-2025
+"""
+
+from .contracts import IParamExtractor
+from .errors import ParserError, ParseError
+from .base import AParamExtractor
+from .sql_param_extractor import SQLParamExtractor
+
+__all__ = [
+    'IParamExtractor',
+    'ParserError',
+    'ParseError',
+    'AParamExtractor',
+    'SQLParamExtractor',
+]
+