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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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