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

exonware/xwnode/nodes/strategies/node_linked_list.py

@@ -1,413 +0,0 @@
-"""
-Linked List Node Strategy Implementation
-
-This module implements the LINKED_LIST strategy for efficient
-insertions and deletions with sequential access patterns.
-"""
-
-from typing import Any, Iterator, List, Dict, Optional
-from ._base_node import aNodeStrategy
-from ...defs import NodeMode, NodeTrait
-
-
-class ListNode:
-    """Node in the doubly linked list."""
-    
-    def __init__(self, key: str, value: Any):
-        self.key = key
-        self.value = value
-        self.prev: Optional['ListNode'] = None
-        self.next: Optional['ListNode'] = None
-
-
-class xLinkedListStrategy(aNodeStrategy):
-    """
-    Linked List node strategy for efficient insertions and deletions.
-    
-    Provides O(1) insertions/deletions at known positions with
-    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)
-        
-        self.doubly_linked = options.get('doubly_linked', True)
-        
-        # Doubly linked list with sentinel nodes
-        self._head = ListNode("HEAD", None)
-        self._tail = ListNode("TAIL", None)
-        self._head.next = self._tail
-        self._tail.prev = self._head
-        
-        # Quick access mapping
-        self._key_to_node: Dict[str, ListNode] = {}
-        self._size = 0
-    
-    def get_supported_traits(self) -> NodeTrait:
-        """Get the traits supported by the linked list strategy."""
-        return (NodeTrait.ORDERED | NodeTrait.INDEXED)
-    
-    def _insert_after(self, prev_node: ListNode, key: str, value: Any) -> ListNode:
-        """Insert new node after given node."""
-        new_node = ListNode(key, value)
-        next_node = prev_node.next
-        
-        # Link new node
-        prev_node.next = new_node
-        new_node.prev = prev_node
-        new_node.next = next_node
-        next_node.prev = new_node
-        
-        return new_node
-    
-    def _remove_node(self, node: ListNode) -> None:
-        """Remove node from list."""
-        prev_node = node.prev
-        next_node = node.next
-        
-        prev_node.next = next_node
-        next_node.prev = prev_node
-        
-        # Clear references
-        node.prev = None
-        node.next = None
-    
-    def _get_node_at_index(self, index: int) -> Optional[ListNode]:
-        """Get node at given index."""
-        if index < 0 or index >= self._size:
-            return None
-        
-        # Optimize direction based on index
-        if index < self._size // 2:
-            # Search from head
-            current = self._head.next
-            for _ in range(index):
-                current = current.next
-        else:
-            # Search from tail
-            current = self._tail.prev
-            for _ in range(self._size - index - 1):
-                current = current.prev
-        
-        return current if current != self._head and current != self._tail else None
-    
-    # ============================================================================
-    # CORE OPERATIONS (Key-based interface for compatibility)
-    # ============================================================================
-    
-    def put(self, key: Any, value: Any = None) -> None:
-        """Add/update key-value pair."""
-        key_str = str(key)
-        
-        if key_str in self._key_to_node:
-            # Update existing
-            self._key_to_node[key_str].value = value
-        else:
-            # Insert at end
-            new_node = self._insert_after(self._tail.prev, key_str, value)
-            self._key_to_node[key_str] = new_node
-            self._size += 1
-    
-    def get(self, key: Any, default: Any = None) -> Any:
-        """Get value by key."""
-        key_str = str(key)
-        
-        if key_str == "list_info":
-            return {
-                'size': self._size,
-                'doubly_linked': self.doubly_linked,
-                'first': self.first(),
-                'last': self.last()
-            }
-        elif key_str.isdigit():
-            # Numeric access by index
-            index = int(key_str)
-            node = self._get_node_at_index(index)
-            return node.value if node else default
-        
-        node = self._key_to_node.get(key_str)
-        return node.value if node else default
-    
-    def has(self, key: Any) -> bool:
-        """Check if key exists."""
-        key_str = str(key)
-        
-        if key_str == "list_info":
-            return True
-        elif key_str.isdigit():
-            index = int(key_str)
-            return 0 <= index < self._size
-        
-        return key_str in self._key_to_node
-    
-    def remove(self, key: Any) -> bool:
-        """Remove key from list."""
-        key_str = str(key)
-        
-        if key_str.isdigit():
-            # Remove by index
-            index = int(key_str)
-            node = self._get_node_at_index(index)
-            if node:
-                self._remove_node(node)
-                del self._key_to_node[node.key]
-                self._size -= 1
-                return True
-            return False
-        
-        node = self._key_to_node.get(key_str)
-        if node:
-            self._remove_node(node)
-            del self._key_to_node[key_str]
-            self._size -= 1
-            return True
-        
-        return False
-    
-    def delete(self, key: Any) -> bool:
-        """Remove key from list (alias for remove)."""
-        return self.remove(key)
-    
-    def clear(self) -> None:
-        """Clear all data."""
-        self._head.next = self._tail
-        self._tail.prev = self._head
-        self._key_to_node.clear()
-        self._size = 0
-    
-    def keys(self) -> Iterator[str]:
-        """Get all keys in insertion order."""
-        current = self._head.next
-        while current != self._tail:
-            yield current.key
-            current = current.next
-    
-    def values(self) -> Iterator[Any]:
-        """Get all values in insertion order."""
-        current = self._head.next
-        while current != self._tail:
-            yield current.value
-            current = current.next
-    
-    def items(self) -> Iterator[tuple[str, Any]]:
-        """Get all key-value pairs in insertion order."""
-        current = self._head.next
-        while current != self._tail:
-            yield (current.key, current.value)
-            current = current.next
-    
-    def __len__(self) -> int:
-        """Get number of elements."""
-        return self._size
-    
-    def to_native(self) -> List[Any]:
-        """Convert to native Python list."""
-        return list(self.values())
-    
-    @property
-    def is_list(self) -> bool:
-        """This is a list strategy."""
-        return True
-    
-    @property
-    def is_dict(self) -> bool:
-        """This also behaves like a dict."""
-        return True
-    
-    # ============================================================================
-    # LINKED LIST SPECIFIC OPERATIONS
-    # ============================================================================
-    
-    def append(self, value: Any) -> str:
-        """Append value to end of list."""
-        key = str(self._size)
-        self.put(key, value)
-        return key
-    
-    def prepend(self, value: Any) -> str:
-        """Prepend value to beginning of list."""
-        key = f"prepend_{self._size}"
-        new_node = self._insert_after(self._head, key, value)
-        self._key_to_node[key] = new_node
-        self._size += 1
-        return key
-    
-    def insert_at(self, index: int, value: Any) -> str:
-        """Insert value at specific index."""
-        if index < 0 or index > self._size:
-            raise IndexError(f"Index {index} out of range")
-        
-        if index == 0:
-            return self.prepend(value)
-        elif index == self._size:
-            return self.append(value)
-        
-        # Find insertion point
-        prev_node = self._get_node_at_index(index - 1)
-        if not prev_node:
-            raise IndexError(f"Cannot find insertion point at index {index}")
-        
-        key = f"insert_{index}_{self._size}"
-        new_node = self._insert_after(prev_node, key, value)
-        self._key_to_node[key] = new_node
-        self._size += 1
-        return key
-    
-    def pop(self) -> Any:
-        """Remove and return last element."""
-        if self._size == 0:
-            raise IndexError("pop from empty list")
-        
-        last_node = self._tail.prev
-        value = last_node.value
-        self._remove_node(last_node)
-        del self._key_to_node[last_node.key]
-        self._size -= 1
-        return value
-    
-    def popleft(self) -> Any:
-        """Remove and return first element."""
-        if self._size == 0:
-            raise IndexError("popleft from empty list")
-        
-        first_node = self._head.next
-        value = first_node.value
-        self._remove_node(first_node)
-        del self._key_to_node[first_node.key]
-        self._size -= 1
-        return value
-    
-    def first(self) -> Any:
-        """Get first element without removing."""
-        if self._size == 0:
-            return None
-        return self._head.next.value
-    
-    def last(self) -> Any:
-        """Get last element without removing."""
-        if self._size == 0:
-            return None
-        return self._tail.prev.value
-    
-    def reverse(self) -> None:
-        """Reverse the list in place."""
-        if self._size <= 1:
-            return
-        
-        # Swap all next/prev pointers
-        current = self._head
-        while current:
-            current.next, current.prev = current.prev, current.next
-            current = current.prev  # Note: we swapped, so prev is now next
-        
-        # Swap head and tail
-        self._head, self._tail = self._tail, self._head
-    
-    def get_at_index(self, index: int) -> Any:
-        """Get value at specific index."""
-        node = self._get_node_at_index(index)
-        if not node:
-            raise IndexError(f"Index {index} out of range")
-        return node.value
-    
-    def set_at_index(self, index: int, value: Any) -> None:
-        """Set value at specific index."""
-        node = self._get_node_at_index(index)
-        if not node:
-            raise IndexError(f"Index {index} out of range")
-        node.value = value
-    
-    def find_index(self, value: Any) -> int:
-        """Find index of first occurrence of value."""
-        current = self._head.next
-        index = 0
-        
-        while current != self._tail:
-            if current.value == value:
-                return index
-            current = current.next
-            index += 1
-        
-        return -1
-    
-    def remove_value(self, value: Any) -> bool:
-        """Remove first occurrence of value."""
-        current = self._head.next
-        
-        while current != self._tail:
-            if current.value == value:
-                self._remove_node(current)
-                del self._key_to_node[current.key]
-                self._size -= 1
-                return True
-            current = current.next
-        
-        return False
-    
-    def count_value(self, value: Any) -> int:
-        """Count occurrences of value."""
-        count = 0
-        current = self._head.next
-        
-        while current != self._tail:
-            if current.value == value:
-                count += 1
-            current = current.next
-        
-        return count
-    
-    def to_array(self) -> List[Any]:
-        """Convert to array representation."""
-        return list(self.values())
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """Get comprehensive linked list statistics."""
-        return {
-            'size': self._size,
-            'doubly_linked': self.doubly_linked,
-            'first_value': self.first(),
-            'last_value': self.last(),
-            'memory_overhead': self._size * (64 if self.doubly_linked else 32),  # Pointer overhead
-            'access_pattern': 'sequential'
-        }
-    
-    # ============================================================================
-    # PERFORMANCE CHARACTERISTICS
-    # ============================================================================
-    
-    @property
-    def backend_info(self) -> Dict[str, Any]:
-        """Get backend implementation info."""
-        return {
-            'strategy': 'LINKED_LIST',
-            'backend': f'{"Doubly" if self.doubly_linked else "Singly"} linked list with sentinel nodes',
-            'doubly_linked': self.doubly_linked,
-            'complexity': {
-                'append': 'O(1)',
-                'prepend': 'O(1)',
-                'insert_at': 'O(n)',
-                'remove_at': 'O(n)',
-                'access_by_index': 'O(n)',
-                'search': 'O(n)',
-                'space': 'O(n)'
-            }
-        }
-    
-    @property
-    def metrics(self) -> Dict[str, Any]:
-        """Get performance metrics."""
-        stats = self.get_statistics()
-        
-        return {
-            'size': stats['size'],
-            'first_value': str(stats['first_value']) if stats['first_value'] is not None else 'None',
-            'last_value': str(stats['last_value']) if stats['last_value'] is not None else 'None',
-            'doubly_linked': stats['doubly_linked'],
-            'memory_overhead': f"{stats['memory_overhead']} bytes",
-            'access_pattern': stats['access_pattern']
-        }

exonware/xwnode/nodes/strategies/node_trie.py

@@ -1,257 +0,0 @@
-"""
-Trie Node Strategy Implementation
-
-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 ...defs import NodeMode, NodeTrait
-from ..utils import (
-    TrieNode,
-    safe_to_native_conversion,
-    create_basic_metrics,
-    create_basic_backend_info,
-    create_size_tracker,
-    create_access_tracker,
-    update_size_tracker,
-    record_access,
-    get_access_metrics
-)
-
-
-class TrieStrategy(ANodeTreeStrategy):
-    """
-    Trie node strategy for efficient string prefix operations.
-    
-    Optimized for prefix matching, autocomplet
-    
-    # Strategy type classification
-    STRATEGY_TYPE = NodeType.TREE
-e, and string searching.
-    """
-    
-    def __init__(self, traits: NodeTrait = NodeTrait.NONE, **options):
-        """Initialize the trie strategy."""
-        super().__init__(NodeMode.TRIE, traits, **options)
-        self._root = TrieNode()
-        self._size_tracker = create_size_tracker()
-        self._access_tracker = create_access_tracker()
-    
-    def get_supported_traits(self) -> NodeTrait:
-        """Get the traits supported by the trie strategy."""
-        return (NodeTrait.ORDERED | NodeTrait.HIERARCHICAL | NodeTrait.INDEXED)
-    
-    # ============================================================================
-    # CORE OPERATIONS
-    # ============================================================================
-    
-    def put(self, key: Any, value: Any = None) -> None:
-        """Store a key-value pair (key should be string-like)."""
-        word = str(key)
-        node = self._root
-        
-        # Traverse/create path
-        for char in word:
-            if char not in node.children:
-                node.children[char] = TrieNode()
-            node = node.children[char]
-        
-        # Mark end and store value
-        if not node.is_end_word:
-            update_size_tracker(self._size_tracker, 1)
-        node.is_end_word = True
-        node.value = value
-        record_access(self._access_tracker, 'put_count')
-    
-    def get(self, key: Any, default: Any = None) -> Any:
-        """Retrieve a value by key."""
-        word = str(key)
-        node = self._find_node(word)
-        record_access(self._access_tracker, 'get_count')
-        if node and node.is_end_word:
-            return node.value
-        return default
-    
-    def has(self, key: Any) -> bool:
-        """Check if key exists."""
-        word = str(key)
-        node = self._find_node(word)
-        return node is not None and node.is_end_word
-    
-    def remove(self, key: Any) -> bool:
-        """Remove a key-value pair."""
-        word = str(key)
-        result = self._remove_recursive(self._root, word, 0)
-        if result:
-            update_size_tracker(self._size_tracker, -1)
-            record_access(self._access_tracker, 'delete_count')
-        return result
-    
-    def delete(self, key: Any) -> bool:
-        """Remove a key-value pair (alias for remove)."""
-        return self.remove(key)
-    
-    def clear(self) -> None:
-        """Clear all data."""
-        self._root = TrieNode()
-        self._size_tracker['size'] = 0
-    
-    def keys(self) -> Iterator[str]:
-        """Get all keys."""
-        return iter(self._collect_words())
-    
-    def values(self) -> Iterator[Any]:
-        """Get all values."""
-        words = self._collect_words()
-        for word in words:
-            node = self._find_node(word)
-            if node:
-                yield node.value
-    
-    def items(self) -> Iterator[tuple[str, Any]]:
-        """Get all key-value pairs."""
-        words = self._collect_words()
-        for word in words:
-            node = self._find_node(word)
-            if node:
-                yield (word, node.value)
-    
-    def __len__(self) -> int:
-        """Get the number of items."""
-        return self._size_tracker['size']
-    
-    def to_native(self) -> Dict[str, Any]:
-        """Convert to native Python dictionary."""
-        result = {}
-        for word in self._collect_words():
-            node = self._find_node(word)
-            if node:
-                result[word] = safe_to_native_conversion(node.value)
-        return result
-    
-    @property
-    def is_list(self) -> bool:
-        """This is not a list strategy."""
-        return False
-    
-    @property
-    def is_dict(self) -> bool:
-        """This behaves like a dict with string keys."""
-        return True
-    
-    # ============================================================================
-    # TRIE-SPECIFIC OPERATIONS
-    # ============================================================================
-    
-    def starts_with(self, prefix: str) -> List[str]:
-        """Get all keys that start with the given prefix."""
-        node = self._find_node(prefix)
-        if not node:
-            return []
-        
-        words = []
-        self._collect_words_from_node(node, prefix, words)
-        return words
-    
-    def longest_common_prefix(self) -> str:
-        """Find the longest common prefix of all stored keys."""
-        if not self._root.children:
-            return ""
-        
-        prefix = ""
-        node = self._root
-        
-        while len(node.children) == 1 and not node.is_end_word:
-            char = next(iter(node.children.keys()))
-            prefix += char
-            node = node.children[char]
-        
-        return prefix
-    
-    def get_all_prefixes(self, word: str) -> List[str]:
-        """Get all prefixes of the given word that exist in the trie."""
-        prefixes = []
-        node = self._root
-        
-        for i, char in enumerate(word):
-            if char not in node.children:
-                break
-            node = node.children[char]
-            if node.is_end_word:
-                prefixes.append(word[:i+1])
-        
-        return prefixes
-    
-    # ============================================================================
-    # HELPER METHODS
-    # ============================================================================
-    
-    def _find_node(self, word: str) -> Optional[TrieNode]:
-        """Find the node corresponding to the given word."""
-        node = self._root
-        for char in word:
-            if char not in node.children:
-                return None
-            node = node.children[char]
-        return node
-    
-    def _remove_recursive(self, node: TrieNode, word: str, index: int) -> bool:
-        """Recursively remove a word from the trie."""
-        if index == len(word):
-            if node.is_end_word:
-                node.is_end_word = False
-                node.value = None
-                return True
-            return False
-        
-        char = word[index]
-        if char not in node.children:
-            return False
-        
-        child = node.children[char]
-        should_delete_child = self._remove_recursive(child, word, index + 1)
-        
-        if should_delete_child and not child.is_end_word and not child.children:
-            del node.children[char]
-        
-        return should_delete_child
-    
-    def _collect_words(self) -> List[str]:
-        """Collect all words stored in the trie."""
-        words = []
-        self._collect_words_from_node(self._root, "", words)
-        return words
-    
-    def _collect_words_from_node(self, node: TrieNode, prefix: str, words: List[str]) -> None:
-        """Collect all words from a given node."""
-        if node.is_end_word:
-            words.append(prefix)
-        
-        for char, child in node.children.items():
-            self._collect_words_from_node(child, prefix + char, words)
-    
-    # ============================================================================
-    # PERFORMANCE CHARACTERISTICS
-    # ============================================================================
-    
-    def backend_info(self) -> Dict[str, Any]:
-        """Get backend implementation info."""
-        return create_basic_backend_info(
-            'TRIE',
-            'TrieNode tree',
-            complexity={
-                'get': 'O(m) where m is key length',
-                'put': 'O(m) where m is key length',
-                'has': 'O(m) where m is key length',
-                'starts_with': 'O(m + k) where m is prefix length, k is number of matches'
-            }
-        )
-    
-    def metrics(self) -> Dict[str, Any]:
-        """Get performance metrics."""
-        base_metrics = create_basic_metrics('TRIE', self._size_tracker['size'])
-        access_metrics = get_access_metrics(self._access_tracker)
-        base_metrics.update(access_metrics)
-        return base_metrics