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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,50 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/union_executor.py
-
-UNION 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 UnionExecutor(AUniversalOperationExecutor):
-    """
-    UNION operation executor.
-    
-    Unions data from multiple sources
-    
-    Capability: Universal
-    Operation Type: JOINING
-    """
-    
-    OPERATION_NAME = "UNION"
-    OPERATION_TYPE = OperationType.JOINING
-    SUPPORTED_NODE_TYPES = []  # Universal
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute UNION operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_union(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_union(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute union logic."""
-        # Implementation here
-        return {'result': 'UNION executed', 'params': params}

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

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-"""
-#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/window_executor.py
-
-WINDOW 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 WindowExecutor(AOperationExecutor):
-    """
-    WINDOW operation executor.
-    
-    Window functions for time-series
-    
-    Capability: LINEAR, TREE only
-    Operation Type: WINDOW
-    """
-    
-    OPERATION_NAME = "WINDOW"
-    OPERATION_TYPE = OperationType.WINDOW
-    SUPPORTED_NODE_TYPES = [NodeType.LINEAR, NodeType.TREE]
-    
-    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
-        """Execute WINDOW operation."""
-        params = action.params
-        node = context.node
-        
-        result_data = self._execute_window(node, params, context)
-        
-        return ExecutionResult(
-            success=True,
-            data=result_data,
-            operation=self.OPERATION_NAME,
-            metadata={'operation': self.OPERATION_NAME}
-        )
-    
-    def _execute_window(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
-        """Execute window logic."""
-        # Implementation here
-        return {'result': 'WINDOW executed', 'params': params}

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

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

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

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

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

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

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

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