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

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

@@ -7,6 +7,7 @@ with fast indexed access.
 
 from typing import Any, Iterator, List, Union, Dict
 from .base import ANodeLinearStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -14,7 +15,11 @@ class ArrayListStrategy(ANodeLinearStrategy):
     """
     Array List node strategy for sequential data with O(1) indexed access.
     
-    Uses Python's built-in list for optimal performance with indexed operations.
+    Uses Python's built-in list for optimal performance 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+with indexed operations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,12 +7,13 @@ This module defines the abstract base classes for all node strategy implementati
 - ANodeLinearStrategy: Phase 1 - Linear data structure capabilities
 - ANodeTreeStrategy: Phase 2 - Tree data structure capabilities  
 - ANodeGraphStrategy: Phase 3&4 - Graph data structure capabilities
+- ANodeMatrixStrategy: Matrix-based data structure capabilities
 
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
-Generation Date: January 2, 2025
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
 """
 
 from abc import ABC, abstractmethod
@@ -20,10 +21,17 @@ from typing import Any, Optional, List, Dict, Iterator
 
 from ...contracts import iNodeStrategy
 from ...errors import XWNodeTypeError, XWNodeValueError
+from .contracts import NodeType
 
 
-class ANodeStrategy(ABC):
-    """Base strategy for all node implementations."""
+class ANodeStrategy(iNodeStrategy):
+    """Base strategy for all node implementations - extends iNodeStrategy interface."""
+    
+    # Strategy type classification (must be overridden by subclasses)
+    STRATEGY_TYPE: NodeType = NodeType.TREE  # Default for backward compatibility
+    
+    # Supported operations (empty = all universal operations)
+    SUPPORTED_OPERATIONS: List[str] = []
     
     def __init__(self, data: Any = None, **options):
         """Initialize node strategy."""
@@ -74,6 +82,9 @@ class ANodeStrategy(ABC):
 class ANodeLinearStrategy(ANodeStrategy):
     """Phase 1: Linear data structure capabilities."""
     
+    # Linear node type
+    STRATEGY_TYPE: NodeType = NodeType.LINEAR
+    
     def push_front(self, value: Any) -> None:
         """Add element to front."""
         raise NotImplementedError("Subclasses must implement push_front")
@@ -119,6 +130,9 @@ class ANodeLinearStrategy(ANodeStrategy):
 class ANodeGraphStrategy(ANodeStrategy):
     """Phase 3&4: Graph data structure capabilities."""
     
+    # Graph node type
+    STRATEGY_TYPE: NodeType = NodeType.GRAPH
+    
     def add_edge(self, from_node: Any, to_node: Any, weight: float = 1.0) -> None:
         """Add edge between nodes."""
         raise NotImplementedError("Subclasses must implement add_edge")
@@ -160,6 +174,9 @@ class ANodeGraphStrategy(ANodeStrategy):
 class ANodeMatrixStrategy(ANodeStrategy):
     """Matrix-based data structure capabilities."""
     
+    # Matrix node type
+    STRATEGY_TYPE: NodeType = NodeType.MATRIX
+    
     def get_dimensions(self) -> tuple:
         """Get matrix dimensions (rows, cols)."""
         raise NotImplementedError("Subclasses must implement get_dimensions")
@@ -209,6 +226,9 @@ class ANodeMatrixStrategy(ANodeStrategy):
 class ANodeTreeStrategy(ANodeGraphStrategy):
     """Phase 2: Tree data structure capabilities."""
     
+    # Tree node type
+    STRATEGY_TYPE: NodeType = NodeType.TREE
+    
     def insert(self, key: Any, value: Any) -> None:
         """Insert with tree ordering."""
         raise NotImplementedError("Subclasses must implement insert")

exonware/xwnode/nodes/strategies/contracts.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/nodes/strategies/contracts.py
+
+Node Strategy Contracts
+
+This module defines contracts and enums for node strategies,
+including the NodeType classification system for operation routing.
+
+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, auto
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional, Iterator
+
+
+class NodeType(Enum):
+    """
+    Node strategy type classification.
+    
+    Used to determine which operations can be executed on a node.
+    """
+    LINEAR = auto()    # Array-like, sequential access (lists, stacks, queues)
+    TREE = auto()      # Hierarchical, key-based ordering (maps, trees, tries)
+    GRAPH = auto()     # Nodes with relationships (union-find, graphs)
+    MATRIX = auto()    # 2D grid access (bitmaps, matrices)
+    HYBRID = auto()    # Combination of multiple types
+
+
+class INodeStrategy(ABC):
+    """
+    Base interface for all node strategies.
+    
+    All node strategies must implement this interface and declare their type
+    and supported operations.
+    """
+    
+    # Strategy type classification (must be set by each strategy)
+    STRATEGY_TYPE: NodeType = NodeType.TREE  # Default
+    
+    # Supported operations (can be overridden by each strategy)
+    SUPPORTED_OPERATIONS: List[str] = []  # Empty = supports all universal operations
+    
+    @abstractmethod
+    def insert(self, key: Any, value: Any) -> None:
+        """Insert key-value pair."""
+        pass
+    
+    @abstractmethod
+    def find(self, key: Any) -> Optional[Any]:
+        """Find value by key."""
+        pass
+    
+    @abstractmethod
+    def delete(self, key: Any) -> bool:
+        """Delete by key."""
+        pass
+    
+    @abstractmethod
+    def size(self) -> int:
+        """Get size of structure."""
+        pass
+    
+    @abstractmethod
+    def is_empty(self) -> bool:
+        """Check if structure is empty."""
+        pass
+    
+    @abstractmethod
+    def to_native(self) -> Any:
+        """Convert to native Python object."""
+        pass
+    
+    @abstractmethod
+    def keys(self) -> Iterator[Any]:
+        """Get iterator over keys."""
+        pass
+    
+    @abstractmethod
+    def values(self) -> Iterator[Any]:
+        """Get iterator over values."""
+        pass
+    
+    @abstractmethod
+    def items(self) -> Iterator[tuple[Any, Any]]:
+        """Get iterator over key-value pairs."""
+        pass
+    
+    @classmethod
+    def get_strategy_type(cls) -> NodeType:
+        """Get the strategy type for this class."""
+        return cls.STRATEGY_TYPE
+    
+    @classmethod
+    def get_supported_operations(cls) -> List[str]:
+        """Get list of explicitly supported operations."""
+        return cls.SUPPORTED_OPERATIONS
+    
+    @classmethod
+    def supports_operation(cls, operation: str) -> bool:
+        """Check if this strategy supports a specific operation."""
+        # Empty list means supports all universal operations
+        if not cls.SUPPORTED_OPERATIONS:
+            return True
+        return operation in cls.SUPPORTED_OPERATIONS
+
+
+__all__ = [
+    'NodeType',
+    'INodeStrategy',
+]

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

@@ -6,13 +6,14 @@ Implements a double-ended queue using Python's deque for efficient operations at
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.13
+Version: 0.0.1.15
 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 DequeStrategy(ANodeLinearStrategy):
     Deque (Double-ended queue) node strategy for efficient operations at both ends.
     
     Provides O(1) operations for adding/removing elements at both front and back,
-    ideal for sliding window algorithms and breadth-first search.
+    ideal for sliding window algorithms a
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+nd breadth-first search.
     """
     
     def __init__(self):

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

@@ -7,6 +7,7 @@ using Python's built-in dictionary.
 
 from typing import Any, Iterator, Dict, List, Optional, Union
 from .base import ANodeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -18,6 +19,9 @@ class HashMapStrategy(ANodeStrategy):
     with associative operations.
     """
     
+    # HashMap is a tree/map structure (key-based access)
+    STRATEGY_TYPE = NodeType.TREE
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the hash map strategy."""
         super().__init__(data=None, **options)

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

@@ -7,6 +7,7 @@ This module implements the HEAP strategy for priority queue operations.
 import heapq
 from typing import Any, Iterator, List, Optional, Dict
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -51,7 +52,11 @@ class xHeapStrategy(ANodeTreeStrategy):
     """
     Heap node strategy for priority queue operations.
     
-    Optimized for push, pop, and peek operations with configurable min/max behavior.
+    Optimized for push, pop, and peek operations with config
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+urable min/max behavior.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,6 +7,7 @@ insertions and deletions with sequential access patterns.
 
 from typing import Any, Iterator, List, Dict, Optional
 from .base import ANodeLinearStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -25,7 +26,11 @@ class LinkedListStrategy(ANodeLinearStrategy):
     Linked List node strategy for efficient insertions and deletions.
     
     Provides O(1) insertions/deletions at known positions with
-    sequential access patterns optimized for iteration.
+    sequential access patterns 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+optimized for iteration.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -8,6 +8,7 @@ string matching using the Aho-Corasick automaton algorithm.
 from typing import Any, Iterator, List, Dict, Set, Optional, Tuple
 from collections import deque, defaultdict
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -31,7 +32,11 @@ class AhoCorasickStrategy(ANodeTreeStrategy):
     Aho-Corasick node strategy for multi-pattern string matching.
     
     Efficiently searches for multiple patterns simultaneously in a text
-    using a finite automaton with failure links for linear-time matching.
+    using a finite automaton with failure links f
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+or linear-time matching.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -17,6 +17,10 @@ class xArrayListStrategy(aNodeStrategy):
     Uses Python's built-in list for optimal performance with indexed operations.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the array list strategy."""
         super().__init__(NodeMode.ARRAY_LIST, traits, **options)

exonware/xwnode/{strategies/nodes → nodes/strategies}/node_avl_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
 
 
@@ -42,7 +43,11 @@ class AVLTreeStrategy(ANodeTreeStrategy):
     AVL tree node strategy for strictly balanced binary search trees.
     
     Provides guaranteed O(log n) height and operations through height-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_b_plus_tree.py

@@ -7,6 +7,7 @@ operations with efficient range queries and sequential access.
 
 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 BPlusTreeStrategy(ANodeTreeStrategy):
     B+ Tree node strategy for database-friendly operations.
     
     Provides efficient range queries, sequential access, and balanced
-    tree operations optimized for disk-based storage systems.
+    tree operations optimized for dis
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+k-based storage systems.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -8,6 +8,7 @@ and boolean operations with compressed storage.
 from typing import Any, Iterator, List, Dict, Optional, Union
 import array
 from .base import ANodeMatrixStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -16,7 +17,11 @@ class BitmapStrategy(ANodeMatrixStrategy):
     Bitmap node strategy for efficient bit manipulation and boolean operations.
     
     Provides space-efficient storage for boolean flags and supports
-    fast bitwise operations with compressed representation.
+    fast bitwise operations with co
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+mpressed representation.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,6 +7,7 @@ operations with automatic resizing and bit manipulation capabilities.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple, Union
 from .base import ANodeMatrixStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -15,7 +16,11 @@ class BitsetDynamicStrategy(ANodeMatrixStrategy):
     Dynamic Bitset node strategy for bit manipulation operations.
     
     Provides efficient set operations, bit manipulation, and automatic
-    resizing for large-scale boolean data processing.
+    resizing for large-scale 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+boolean data processing.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -9,6 +9,7 @@ from typing import Any, Iterator, List, Dict, Optional
 import hashlib
 import math
 from ._base_node import aNodeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -22,6 +23,9 @@ class xBloomFilterStrategy(aNodeStrategy):
     - Configurable false positive rate
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the Bloom Filter strategy."""
         super().__init__(NodeMode.BLOOM_FILTER, traits, **options)

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

@@ -7,6 +7,7 @@ and sorted key operations with guaranteed O(log n) performance.
 
 from typing import Any, Iterator, List, Optional, Union, Dict
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -93,7 +94,11 @@ class BTreeStrategy(ANodeTreeStrategy):
     B-Tree node strategy for efficient sorted operations and range queries.
     
     Provides O(log n) search, insert, and delete operations with excellent
-    cache performance for range queries.
+    cache perfor
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+mance for range queries.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -20,6 +20,10 @@ class xCountMinSketchStrategy(aNodeStrategy):
     probabilistic error bounds and no false negatives.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the Count-Min Sketch strategy."""
         super().__init__(NodeMode.COUNT_MIN_SKETCH, traits, **options)

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

@@ -8,6 +8,7 @@ atomic snapshots and versioning capabilities.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple, Set
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -65,7 +66,11 @@ class COWTreeStrategy(ANodeTreeStrategy):
     Copy-on-write tree node strategy with atomic snapshots.
     
     Provides instant snapshots, atomic updates, and versioning through
-    copy-on-write semantics with reference counting.
+    copy-on-write semantics 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+with reference counting.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,6 +7,7 @@ queries and point updates with O(log n) complexity.
 
 from typing import Any, Iterator, List, Dict, Union
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -15,7 +16,11 @@ class FenwickTreeStrategy(ANodeTreeStrategy):
     Fenwick Tree node strategy for efficient prefix sum operations.
     
     Also known as Binary Indexed Tree (BIT), provides O(log n) prefix sum
-    queries and point updates with minimal memory overhead.
+    queries and point updates with 
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+minimal memory overhead.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -29,6 +29,10 @@ class xHashMapStrategy(aNodeStrategy):
     with associative operations.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the hash map strategy."""
         super().__init__(NodeMode.HASH_MAP, traits, **options)

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

@@ -7,6 +7,7 @@ This module implements the HEAP strategy for priority queue operations.
 import heapq
 from typing import Any, Iterator, List, Optional, Dict
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 from ..utils import (
     MinHeap,
@@ -25,7 +26,11 @@ class HeapStrategy(ANodeTreeStrategy):
     """
     Heap node strategy for priority queue operations.
     
-    Optimized for push, pop, and peek operations with configurable min/max behavior.
+    Optimized for push, pop, and peek operations with config
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+urable min/max behavior.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -20,6 +20,10 @@ class xHyperLogLogStrategy(aNodeStrategy):
     with configurable precision and excellent scalability.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.MATRIX
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the HyperLogLog strategy."""
         super().__init__(NodeMode.HYPERLOGLOG, traits, **options)

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

@@ -28,6 +28,10 @@ class xLinkedListStrategy(aNodeStrategy):
     sequential access patterns optimized for iteration.
     """
     
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.LINEAR
+
+    
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
         """Initialize the Linked List strategy."""
         super().__init__(NodeMode.LINKED_LIST, traits, **options)

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

@@ -10,6 +10,7 @@ import time
 import threading
 from collections import defaultdict
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -92,7 +93,11 @@ class LSMTreeStrategy(ANodeTreeStrategy):
     LSM Tree node strategy for write-heavy workloads.
     
     Provides excellent write performance with eventual read consistency
-    through in-memory memtables and sorted disk-based SSTables.
+    through in-memory memtables and sor
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+ted disk-based SSTables.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -8,6 +8,7 @@ operations with efficient range queries and ordered iteration.
 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 OrderedMapStrategy(ANodeTreeStrategy):
     Ordered Map node strategy for sorted key-value operations.
     
     Maintains keys in sorted order for efficient range queries,
-    ordered iteration, and logarithmic search operations.
+    ordered iteration, and logari
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+thmic search operations.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,6 +7,7 @@ ordered operations with guaranteed 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
 
 
@@ -43,7 +44,11 @@ class OrderedMapBalancedStrategy(ANodeTreeStrategy):
     Balanced Ordered Map node strategy using AVL tree.
     
     Provides guaranteed O(log n) operations with automatic balancing
-    for optimal performance in all scenarios.
+    for optimal perfo
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+rmance in all scenarios.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):

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

@@ -7,6 +7,7 @@ Retrieve Information Coded in Alphanumeric) for binary trie compression.
 
 from typing import Any, Iterator, List, Dict, Optional, Tuple
 from .base import ANodeTreeStrategy
+from .contracts import NodeType
 from ...types import NodeMode, NodeTrait
 
 
@@ -31,7 +32,11 @@ class PatriciaStrategy(ANodeTreeStrategy):
     PATRICIA node strategy for compressed binary trie operations.
     
     Implements PATRICIA algorithm for efficient string storage and
-    retrieval using compressed binary trie structure.
+    retrieval using compresse
+    
+    # Strategy type classification
+    STRATEGY_TYPE = NodeType.TREE
+d binary trie structure.
     """
     
     def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):