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

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_persistent_tree.py

@@ -8,6 +8,7 @@ trees with structural sharing and lock-free concurrency.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -44,7 +45,11 @@ class PersistentTreeStrategy(ANodeTreeStrategy):
     Persistent tree node strategy for immutable functional trees.
     
     Provides lock-free concurrency through immutability and structural sharing.
-    Each operation returns a new tree while sharing unchanged nodes.
+    Each operation returns a new tree while 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+sharing unchanged nodes.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_radix_trie.py

@@ -7,6 +7,7 @@ matching with path compression for memory efficiency.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -30,7 +31,11 @@ class RadixTrieStrategy(ANodeTreeStrategy):
     Radix Trie node strategy for compressed prefix matching.
     
     Provides memory-efficient string storage with path compression
-    and fast prefix-based operations.
+    and fast 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+prefix-based operations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_red_black_tree.py

@@ -8,6 +8,7 @@ search trees with guaranteed O(log n) height and operations.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -59,7 +60,11 @@ class RedBlackTreeStrategy(ANodeTreeStrategy):
     Red-black tree node strategy for self-balancing binary search trees.
     
     Provides guaranteed O(log n) height and operations through color-based
-    balancing rules and rotations.
+    balanc
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+ing rules and rotations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_roaring_bitmap.py

@@ -9,6 +9,7 @@ from typing import Any, Iterator, List, Dict, Optional, Set, Tuple
 from collections import defaultdict
 import struct
 from .base import ANodeMatrixStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -155,7 +156,11 @@ class RoaringBitmapStrategy(ANodeMatrixStrategy):
     
     Uses a hybrid approach with array containers for sparse data
     and bitmap containers for dense data, providing excellent
-    compression and performance characteristics.
+    compression and perf
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+ormance characteristics.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_segment_tree.py

@@ -7,6 +7,7 @@ and updates with O(log n) complexity.
 
 from typing import Any, Iterator, List, Optional, Callable, Dict, Union
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -15,7 +16,11 @@ class SegmentTreeStrategy(ANodeTreeStrategy):
     Segment Tree node strategy for efficient range queries and updates.
     
     Provides O(log n) range queries and updates for associative operations
-    like sum, min, max, etc.
+    
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+like sum, min, max, etc.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_set_hash.py

@@ -19,6 +19,10 @@ class xSetHashStrategy(aNodeStrategy):
     with automatic handling of duplicates and fast set operations.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the Hash Set strategy."""
         super().__init__(NodeMode.SET_HASH, traits, **options)

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_set_tree.py

@@ -7,6 +7,7 @@ using a balanced binary search tree with efficient range queries.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -27,7 +28,11 @@ class SetTreeStrategy(ANodeTreeStrategy):
     Tree Set node strategy for ordered set operations.
     
     Provides efficient ordered set operations with logarithmic complexity
-    for insertions, deletions, and range queries.
+    for insertions, delet
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+ions, and range queries.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_skip_list.py

@@ -9,6 +9,7 @@ with O(log n) expected performance for search, insertion, and deletion.
 import random
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -40,7 +41,11 @@ class SkipListStrategy(ANodeTreeStrategy):
     Skip list node strategy for probabilistic data structures.
     
     Provides O(log n) expected performance for search, insertion, and deletion
-    with simple implementation and good concurrent access properties.
+    with simple implementation and good concu
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+rrent access properties.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_splay_tree.py

@@ -8,6 +8,7 @@ search trees with amortized O(log n) performance.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -40,7 +41,11 @@ class SplayTreeStrategy(ANodeTreeStrategy):
     Splay tree node strategy for self-adjusting binary search trees.
     
     Provides amortized O(log n) performance by moving accessed nodes
-    to the root through splaying operations.
+    to the root thro
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+ugh splaying operations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_suffix_array.py

@@ -8,6 +8,7 @@ searches and string pattern matching with linear time construction.
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 import bisect
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -16,7 +17,11 @@ class SuffixArrayStrategy(ANodeTreeStrategy):
     Suffix Array node strategy for efficient string operations.
     
     Provides fast substring searches, pattern matching, and string analysis
-    with linear space usage and efficient query operations.
+    with linear space usage and eff
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+icient query operations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_treap.py

@@ -9,6 +9,7 @@ combining binary search tree and heap properties.
 import random
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -43,7 +44,11 @@ class TreapStrategy(ANodeTreeStrategy):
     Treap node strategy for randomized balanced trees.
     
     Combines binary search tree and heap properties with randomized
-    priorities for self-balancing behavior.
+    priorities for 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+self-balancing behavior.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_tree_graph_hybrid.py

@@ -529,6 +529,10 @@ class TreeGraphHybridStrategy(iNodeStrategy):
     - Lazy loading and object pooling
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.HYBRID
+
+    
     def __init__(self):
         """Initialize the TreeGraphHybrid strategy."""
         self._root: Optional[TreeGraphNode] = None

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_trie.py

@@ -6,6 +6,7 @@ This module implements the TRIE strategy for efficient string prefix operations.
 
 from typing import Any, Iterator, Dict, List, Optional
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 from ..utils import (
     TrieNode,
@@ -24,7 +25,11 @@ class TrieStrategy(ANodeTreeStrategy):
     """
     Trie node strategy for efficient string prefix operations.
     
-    Optimized for prefix matching, autocomplete, and string searching.
+    Optimized for prefix matching, autocomplet
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+e, and string searching.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_union_find.py

@@ -6,6 +6,7 @@ This module implements the UNION_FIND strategy for efficient set operations.
 
 from typing import Any, Iterator, Dict, List, Set
 from .base import ANodeGraphStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 from ..utils import (
     UnionFind,
@@ -24,7 +25,11 @@ class UnionFindStrategy(ANodeGraphStrategy):
     """
     Union-Find node strategy for efficient set operations.
     
-    Optimized for union, find, and connected operations on disjoint sets.
+    Optimized for union, find, and connected oper
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.GRAPH
+ations on disjoint sets.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_xdata_optimized.py

@@ -36,6 +36,10 @@ class DataInterchangeOptimizedStrategy(aNodeStrategy):
     - Zero graph/edge overhead
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.HYBRID
+
+    
     __slots__ = (
         '_data', '_size', '_hash_cache', '_frozen', '_cow_enabled',
         '_pool_ref', '_creation_time', '_access_count', 'mode', 'traits', 'options'

exonware/xwnode/{strategies/nodes → nodes/strategies}/priority_queue.py

@@ -6,13 +6,14 @@ Implements a priority queue using Python's heapq for efficient priority-based op
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
+Version: 0.0.1.14
 Generation Date: 07-Sep-2025
 """
 
 from typing import Any, Iterator, Optional, Dict, Union, Tuple
 import heapq
 from .base import ANodeLinearStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -21,7 +22,11 @@ class PriorityQueueStrategy(ANodeLinearStrategy):
     Priority Queue node strategy for priority-based operations.
     
     Uses a binary heap for efficient insertion and extraction of
-    highest priority elements, ideal for algorithms like Dijkstra's.
+    highest priority elements, ideal for alg
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+orithms like Dijkstra's.
     """
     
     def __init__(self):

exonware/xwnode/{strategies/nodes → nodes/strategies}/queue.py

@@ -6,13 +6,14 @@ Implements a FIFO (First In, First Out) data structure using Python's deque.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
+Version: 0.0.1.14
 Generation Date: 07-Sep-2025
 """
 
 from typing import Any, Iterator, Optional, Dict, Union
 from collections import deque
 from .base import ANodeLinearStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -21,7 +22,11 @@ class QueueStrategy(ANodeLinearStrategy):
     Queue node strategy for FIFO (First In, First Out) operations.
     
     Provides O(1) enqueue and dequeue operations with efficient memory usage
-    for queue-based algorithms and breadth-first search.
+    for queue-based algorithms a
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+nd breadth-first search.
     """
     
     def __init__(self):

exonware/xwnode/{strategies/nodes → nodes/strategies}/sparse_matrix.py

@@ -6,12 +6,13 @@ Implements a sparse matrix using coordinate format (COO) for memory efficiency.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
+Version: 0.0.1.14
 Generation Date: 07-Sep-2025
 """
 
 from typing import Any, Iterator, List, Optional, Dict, Union, Tuple
 from .base import ANodeMatrixStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -20,7 +21,11 @@ class SparseMatrixStrategy(ANodeMatrixStrategy):
     Sparse Matrix node strategy for memory-efficient matrix operations.
     
     Uses coordinate format (COO) to store only non-zero elements,
-    providing excellent memory efficiency for sparse matrices.
+    providing excellent memory efficie
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+ncy for sparse matrices.
     """
     
     def __init__(self):

exonware/xwnode/{strategies/nodes → nodes/strategies}/stack.py

@@ -6,12 +6,13 @@ Implements a LIFO (Last In, First Out) data structure using Python's list.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
+Version: 0.0.1.14
 Generation Date: 07-Sep-2025
 """
 
 from typing import Any, Iterator, List, Optional, Dict, Union
 from .base import ANodeLinearStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -20,7 +21,11 @@ class StackStrategy(ANodeLinearStrategy):
     Stack node strategy for LIFO (Last In, First Out) operations.
     
     Provides O(1) push and pop operations with efficient memory usage
-    for stack-based algorithms and recursive function simulation.
+    for stack-based algorithms and recurs
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+ive function simulation.
     """
     
     def __init__(self):

exonware/xwnode/{strategies/nodes → nodes/strategies}/trie.py

@@ -6,6 +6,7 @@ This module implements the TRIE strategy for efficient string prefix operations.
 
 from typing import Any, Iterator, Dict, List, Optional
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -22,7 +23,11 @@ class xTrieStrategy(ANodeTreeStrategy):
     """
     Trie node strategy for efficient string prefix operations.
     
-    Optimized for prefix matching, autocomplete, and string searching.
+    Optimized for prefix matching, autocomplet
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+e, and string searching.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/{strategies/nodes → nodes/strategies}/union_find.py

@@ -6,6 +6,7 @@ This module implements the UNION_FIND strategy for efficient set operations.
 
 from typing import Any, Iterator, Dict, List, Set
 from .base import ANodeGraphStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -80,7 +81,11 @@ class xUnionFindStrategy(ANodeGraphStrategy):
     """
     Union-Find node strategy for efficient set operations.
     
-    Optimized for union, find, and connected operations on disjoint sets.
+    Optimized for union, find, and connected oper
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.GRAPH
+ations on disjoint sets.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

exonware/xwnode/queries/executors/__init__.py

@@ -0,0 +1,47 @@
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/__init__.py
+
+Query Operation Executors
+
+This package implements the execution layer for 50 XWQuery Script operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+Generation Date: 08-Oct-2025
+"""
+
+from .contracts import (
+    IOperationExecutor,
+    Action,
+    ExecutionContext,
+    ExecutionResult
+)
+from .types import OperationCapability, OperationType, ExecutionStatus
+from .errors import ExecutorError, OperationExecutionError, ValidationError, UnsupportedOperationError
+from .base import AOperationExecutor
+from .registry import OperationRegistry, get_operation_registry, register_operation
+
+__all__ = [
+    # Contracts
+    'IOperationExecutor',
+    'Action',
+    'ExecutionContext',
+    'ExecutionResult',
+    # Types
+    'OperationCapability',
+    'OperationType',
+    'ExecutionStatus',
+    # Errors
+    'ExecutorError',
+    'OperationExecutionError',
+    'ValidationError',
+    'UnsupportedOperationError',
+    # Base
+    'AOperationExecutor',
+    # Registry
+    'OperationRegistry',
+    'get_operation_registry',
+    'register_operation',
+]

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

@@ -0,0 +1,37 @@
+"""Advanced operation executors."""
+
+from .join_executor import JoinExecutor
+from .union_executor import UnionExecutor
+from .with_cte_executor import WithCteExecutor
+from .aggregate_executor import AggregateExecutor
+from .foreach_executor import ForeachExecutor
+from .let_executor import LetExecutor
+from .for_loop_executor import ForLoopExecutor
+from .window_executor import WindowExecutor
+from .describe_executor import DescribeExecutor
+from .construct_executor import ConstructExecutor
+from .ask_executor import AskExecutor
+from .subscribe_executor import SubscribeExecutor
+from .subscription_executor import SubscriptionExecutor
+from .mutation_executor import MutationExecutor
+from .pipe_executor import PipeExecutor
+from .options_executor import OptionsExecutor
+
+__all__ = [
+    'JoinExecutor',
+    'UnionExecutor',
+    'WithCteExecutor',
+    'AggregateExecutor',
+    'ForeachExecutor',
+    'LetExecutor',
+    'ForLoopExecutor',
+    'WindowExecutor',
+    'DescribeExecutor',
+    'ConstructExecutor',
+    'AskExecutor',
+    'SubscribeExecutor',
+    'SubscriptionExecutor',
+    'MutationExecutor',
+    'PipeExecutor',
+    'OptionsExecutor',
+]

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/aggregate_executor.py
+
+AGGREGATE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+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 AggregateExecutor(AUniversalOperationExecutor):
+    """
+    AGGREGATE operation executor.
+    
+    Window aggregation operations
+    
+    Capability: Universal
+    Operation Type: AGGREGATION
+    """
+    
+    OPERATION_NAME = "AGGREGATE"
+    OPERATION_TYPE = OperationType.AGGREGATION
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute AGGREGATE operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_aggregate(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_aggregate(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute aggregate logic."""
+        # Implementation here
+        return {'result': 'AGGREGATE executed', 'params': params}

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

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/advanced/ask_executor.py
+
+ASK Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.14
+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 AskExecutor(AUniversalOperationExecutor):
+    """
+    ASK operation executor.
+    
+    Boolean query (yes/no result)
+    
+    Capability: Universal
+    Operation Type: ADVANCED
+    """
+    
+    OPERATION_NAME = "ASK"
+    OPERATION_TYPE = OperationType.ADVANCED
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute ASK operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_ask(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_ask(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute ask logic."""
+        # Implementation here
+        return {'result': 'ASK executed', 'params': params}