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

exonware/xwnode/queries/executors/advanced/with_cte_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/with_cte_executor.py
+
+WITH 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 WithCteExecutor(AUniversalOperationExecutor):
+    """
+    WITH operation executor.
+    
+    Common Table Expressions
+    
+    Capability: Universal
+    Operation Type: CONTROL_FLOW
+    """
+    
+    OPERATION_NAME = "WITH"
+    OPERATION_TYPE = OperationType.CONTROL_FLOW
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute WITH operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_with_cte(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_with_cte(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute with_cte logic."""
+        # Implementation here
+        return {'result': 'WITH executed', 'params': params}

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

@@ -0,0 +1,21 @@
+"""Aggregation operation executors."""
+
+from .sum_executor import SumExecutor
+from .avg_executor import AvgExecutor
+from .min_executor import MinExecutor
+from .max_executor import MaxExecutor
+from .distinct_executor import DistinctExecutor
+from .group_executor import GroupExecutor
+from .having_executor import HavingExecutor
+from .summarize_executor import SummarizeExecutor
+
+__all__ = [
+    'SumExecutor',
+    'AvgExecutor',
+    'MinExecutor',
+    'MaxExecutor',
+    'DistinctExecutor',
+    'GroupExecutor',
+    'HavingExecutor',
+    'SummarizeExecutor',
+]

exonware/xwnode/queries/executors/aggregation/avg_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/avg_executor.py
+
+AVG 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 AvgExecutor(AUniversalOperationExecutor):
+    """
+    AVG operation executor.
+    
+    Computes average of numeric values
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "AVG"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute AVG operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_avg(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_avg(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute avg logic."""
+        # Implementation here
+        return {'result': 'AVG executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/count_executor.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/count_executor.py
+
+COUNT Operation Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+
+
+class CountExecutor(AUniversalOperationExecutor):
+    """COUNT operation executor - Universal aggregation."""
+    
+    OPERATION_NAME = "COUNT"
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute COUNT operation."""
+        # Count items in node
+        count = 0
+        
+        if hasattr(context.node, '__len__'):
+            count = len(context.node)
+        elif hasattr(context.node, 'size'):
+            count = context.node.size()
+        elif hasattr(context.node, '_strategy') and hasattr(context.node._strategy, 'size'):
+            count = context.node._strategy.size()
+        
+        return ExecutionResult(data={'count': count}, affected_count=count)
+
+
+__all__ = ['CountExecutor']

exonware/xwnode/queries/executors/aggregation/distinct_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/distinct_executor.py
+
+DISTINCT 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 DistinctExecutor(AUniversalOperationExecutor):
+    """
+    DISTINCT operation executor.
+    
+    Returns distinct/unique values
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "DISTINCT"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute DISTINCT operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_distinct(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_distinct(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute distinct logic."""
+        # Implementation here
+        return {'result': 'DISTINCT executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/group_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/group_executor.py
+
+GROUP 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 GroupExecutor(AUniversalOperationExecutor):
+    """
+    GROUP operation executor.
+    
+    Groups data by specified fields
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "GROUP"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute GROUP operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_group(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_group(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute group logic."""
+        # Implementation here
+        return {'result': 'GROUP executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/having_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/having_executor.py
+
+HAVING 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 HavingExecutor(AUniversalOperationExecutor):
+    """
+    HAVING operation executor.
+    
+    Filters grouped data
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "HAVING"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute HAVING operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_having(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_having(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute having logic."""
+        # Implementation here
+        return {'result': 'HAVING executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/max_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/max_executor.py
+
+MAX 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 MaxExecutor(AUniversalOperationExecutor):
+    """
+    MAX operation executor.
+    
+    Finds maximum value
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "MAX"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute MAX operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_max(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_max(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute max logic."""
+        # Implementation here
+        return {'result': 'MAX executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/min_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/min_executor.py
+
+MIN 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 MinExecutor(AUniversalOperationExecutor):
+    """
+    MIN operation executor.
+    
+    Finds minimum value
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "MIN"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute MIN operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_min(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_min(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute min logic."""
+        # Implementation here
+        return {'result': 'MIN executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/sum_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/sum_executor.py
+
+SUM 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 SumExecutor(AUniversalOperationExecutor):
+    """
+    SUM operation executor.
+    
+    Computes sum of numeric values
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "SUM"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute SUM operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_sum(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_sum(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute sum logic."""
+        # Implementation here
+        return {'result': 'SUM executed', 'params': params}

exonware/xwnode/queries/executors/aggregation/summarize_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/aggregation/summarize_executor.py
+
+SUMMARIZE 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 SummarizeExecutor(AUniversalOperationExecutor):
+    """
+    SUMMARIZE operation executor.
+    
+    Summarizes data with aggregations
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "SUMMARIZE"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute SUMMARIZE operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_summarize(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_summarize(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute summarize logic."""
+        # Implementation here
+        return {'result': 'SUMMARIZE executed', 'params': params}

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

@@ -0,0 +1,9 @@
+"""Array operation executors."""
+
+from .slicing_executor import SlicingExecutor
+from .indexing_executor import IndexingExecutor
+
+__all__ = [
+    'SlicingExecutor',
+    'IndexingExecutor',
+]

exonware/xwnode/queries/executors/array/indexing_executor.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/array/indexing_executor.py
+
+INDEXING 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 IndexingExecutor(AOperationExecutor):
+    """
+    INDEXING operation executor.
+    
+    Array indexing operations
+    
+    Capability: LINEAR, MATRIX, TREE only
+    Operation Type: ARRAY
+    """
+    
+    OPERATION_NAME = "INDEXING"
+    OPERATION_TYPE = OperationType.ARRAY
+    SUPPORTED_NODE_TYPES = [NodeType.LINEAR, NodeType.MATRIX, NodeType.TREE]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute INDEXING operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_indexing(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_indexing(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute indexing logic."""
+        # Implementation here
+        return {'result': 'INDEXING executed', 'params': params}

exonware/xwnode/queries/executors/array/slicing_executor.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/array/slicing_executor.py
+
+SLICING 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 SlicingExecutor(AOperationExecutor):
+    """
+    SLICING operation executor.
+    
+    Array slicing operations
+    
+    Capability: LINEAR, MATRIX only
+    Operation Type: ARRAY
+    """
+    
+    OPERATION_NAME = "SLICING"
+    OPERATION_TYPE = OperationType.ARRAY
+    SUPPORTED_NODE_TYPES = [NodeType.LINEAR, NodeType.MATRIX]
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute SLICING operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_slicing(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_slicing(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute slicing logic."""
+        # Implementation here
+        return {'result': 'SLICING executed', 'params': params}