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

exonware/xwnode/strategies/__init__.py

@@ -15,7 +15,7 @@ This package implements the enhanced strategy system with xwsystem-inspired opti
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.22
+Version: 0.0.1.23
 Generation Date: 07-Sep-2025
 """
 
@@ -44,11 +44,11 @@ from .nodes.stack import StackStrategy
 from .nodes.queue import QueueStrategy
 from .nodes.priority_queue import PriorityQueueStrategy
 from .nodes.deque import DequeStrategy
-from .nodes.trie import xTrieStrategy
-from .nodes.heap import xHeapStrategy
-from .nodes.aho_corasick import xAhoCorasickStrategy
+from .nodes.trie import TrieStrategy
+from .nodes.heap import HeapStrategy
+from .nodes.aho_corasick import AhoCorasickStrategy
 from .nodes.hash_map import HashMapStrategy
-from .nodes.union_find import xUnionFindStrategy
+from .nodes.union_find import UnionFindStrategy
 from .nodes.adjacency_list import AdjacencyListStrategy
 from .nodes.sparse_matrix import SparseMatrixStrategy
 
@@ -57,39 +57,6 @@ from .edges.base import AEdgeStrategy, ALinearEdgeStrategy, ATreeEdgeStrategy, A
 from .edges.adj_list import AdjListStrategy
 from .edges.adj_matrix import AdjMatrixStrategy
 
-# Query strategies
-from .queries.base import AQueryStrategy, AStructuredQueryStrategy, AGraphQueryStrategy, ADocumentQueryStrategy
-from .queries.xwquery_strategy import XWQueryScriptStrategy
-from .queries.xwnode_executor import XWNodeQueryActionExecutor
-from .queries.sql import SQLStrategy
-from .queries.hiveql import HiveQLStrategy
-from .queries.pig import PigStrategy
-from .queries.cql import CQLStrategy
-from .queries.n1ql import N1QLStrategy
-from .queries.kql import KQLStrategy
-from .queries.datalog import DatalogStrategy
-from .queries.mql import MQLStrategy
-from .queries.partiql import PartiQLStrategy
-from .queries.elastic_dsl import ElasticDSLStrategy
-from .queries.eql import EQLStrategy
-from .queries.flux import FluxStrategy
-from .queries.promql import PromQLStrategy
-from .queries.graphql import GraphQLStrategy
-from .queries.sparql import SPARQLStrategy
-from .queries.gremlin import GremlinStrategy
-from .queries.cypher import CypherStrategy
-from .queries.gql import GQLStrategy
-from .queries.linq import LINQStrategy
-from .queries.hql import HQLStrategy
-from .queries.jsoniq import JSONiqStrategy
-from .queries.jmespath import JMESPathStrategy
-from .queries.jq import JQStrategy
-from .queries.xquery import XQueryStrategy
-from .queries.xpath import XPathStrategy
-from .queries.logql import LogQLStrategy
-from .queries.xml_query import XMLQueryStrategy
-from .queries.json_query import JSONQueryStrategy
-
 from ..common.patterns.registry import StrategyRegistry, get_registry, register_node_strategy, register_edge_strategy
 from ..common.patterns.advisor import StrategyAdvisor, get_advisor
 from ..common.management.manager import StrategyManager
@@ -132,19 +99,6 @@ __all__ = [
     # Edge strategy implementations
     'AdjListStrategy', 'AdjMatrixStrategy',
     
-    # Query strategy base classes
-    'AQueryStrategy', 'AStructuredQueryStrategy', 'AGraphQueryStrategy', 'ADocumentQueryStrategy',
-    
-    # Query strategy implementations
-    'XWQueryScriptStrategy', 'XWNodeQueryActionExecutor',
-    'SQLStrategy', 'HiveQLStrategy', 'PigStrategy', 'CQLStrategy', 'N1QLStrategy',
-    'KQLStrategy', 'DatalogStrategy', 'MQLStrategy', 'PartiQLStrategy',
-    'ElasticDSLStrategy', 'EQLStrategy', 'FluxStrategy', 'PromQLStrategy',
-    'GraphQLStrategy', 'SPARQLStrategy', 'GremlinStrategy', 'CypherStrategy', 'GQLStrategy',
-    'LINQStrategy', 'HQLStrategy', 'JSONiqStrategy', 'JMESPathStrategy', 'JQStrategy',
-    'XQueryStrategy', 'XPathStrategy', 'LogQLStrategy',
-    'XMLQueryStrategy', 'JSONQueryStrategy',
-    
     # Strategy management
     'StrategyRegistry', 'get_registry', 'register_node_strategy', 'register_edge_strategy',
     'StrategyAdvisor', 'get_advisor',

exonware/xwnode/version.py

@@ -4,7 +4,7 @@ Centralized version management for xwnode.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Generation Date: October 11, 2025
+Generation Date: October 12, 2025
 
 This module provides centralized version management for the entire xwnode project.
 All version references should import from this module to ensure consistency.
@@ -15,13 +15,13 @@ All version references should import from this module to ensure consistency.
 # =============================================================================
 
 # Main version - update this to change version across entire project
-__version__ = "0.0.1.22"
+__version__ = "0.0.1.23"
 
 # Version components for programmatic access
 VERSION_MAJOR = 0
 VERSION_MINOR = 0
 VERSION_PATCH = 1
-VERSION_BUILD = 22# Set to None for releases, or build number for dev builds
+VERSION_BUILD = 23# Set to None for releases, or build number for dev builds
 
 # Version metadata
 VERSION_SUFFIX = ""  # e.g., "dev", "alpha", "beta", "rc1"

{exonware_xwnode-0.0.1.22.dist-info → exonware_xwnode-0.0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exonware-xwnode
-Version: 0.0.1.22
+Version: 0.0.1.23
 Summary: Node-based data processing and graph computation library
 Project-URL: Homepage, https://exonware.com
 Project-URL: Repository, https://github.com/exonware/xwnode
@@ -40,7 +40,8 @@ Description-Content-Type: text/markdown
 **Company:** eXonware.com  
 **Author:** Eng. Muhammad AlShehri  
 **Email:** connect@exonware.com  
-**Version:** 0.0.1.22
+**Version:** 0.0.1.23
+**Last Updated:** 11-Oct-2025
 
 ## 🎯 **What is xwnode?**
 
@@ -106,12 +107,29 @@ node = XWNode({'data': 'example'})
 
 ## 🚀 **Key Features**
 
+✅ **57 Production-Ready Node Strategies** - Comprehensive data structures (vEB Tree, DAWG, Interval Tree, k-d Tree, CRDT Map, Rope, and more)  
+✅ **Advanced Persistent Structures** - LSM Tree (WAL + Bloom filters), BW Tree (atomic CAS), Learned Index (ML-based)  
+✅ **28 Edge Strategies** - Advanced graph representations (ADJ_LIST, k²-tree, BVGraph, HNSW, Euler Tour, Link-Cut, 2-Hop Labels, Multiplex, and more)  
+✅ **35 Query Languages** - SQL, GraphQL, Cypher, SPARQL, XPath, JMESPath, and more  
+✅ **Production Features** - Version management, memory monitoring, background compaction, lock-free operations  
 ✅ **Node-based architecture** for modular data processing  
 ✅ **Graph computation engine** for complex workflows  
 ✅ **Flexible data flow** between processing nodes  
 ✅ **Reusable components** for common operations  
 ✅ **Performance optimized** for large-scale processing  
-✅ **Easy integration** with existing Python data tools  
+✅ **Easy integration** with existing Python data tools
+
+### **🎯 Production-Grade Node Strategies (51 Total)**
+
+**Linear Structures (7):** Stack, Queue, Deque, Priority Queue, Linked List, Array List, Circular Buffer  
+**Hash-Based (7):** HashMap, OrderedMap, HAMT, Cuckoo Hash, Linear Hash, Extendible Hash, Set Hash  
+**Tree Structures (18):** AVL, Red-Black, B-Tree, B+ Tree, Trie, Radix, Patricia, Splay, Treap, Skip List, Heap, ART, and more  
+**Advanced (5):** LSM Tree (WAL + Bloom), BW Tree (atomic CAS), Learned Index (ML), Persistent Tree (versioning), COW Tree (memory monitoring)  
+**Matrix/Bitmap (5):** Bitmap, Dynamic Bitset, Roaring Bitmap, Sparse Matrix, Adjacency List  
+**Probabilistic (3):** Bloom Filter, Count-Min Sketch, HyperLogLog  
+**Specialized (6):** Union Find, Segment Tree, Fenwick Tree, Suffix Array, Aho-Corasick, Data Interchange
+
+📖 **[Complete Strategy Guide & Selection Matrix](docs/STRATEGIES.md)**  
 
 ## 🚀 **Project Phases**
 
@@ -131,6 +149,8 @@ xWNode follows a structured 5-phase development approach designed to deliver ent
 
 ## 📚 **Documentation**
 
+- **[Strategy Selection Guide](docs/STRATEGIES.md)** - Complete 51-strategy matrix with production readiness status
+- **[Production Readiness Summary](docs/PRODUCTION_READINESS_SUMMARY.md)** - Detailed improvements and test results
 - **[API Documentation](docs/)** - Complete reference and examples
 - **[Examples](examples/)** - Practical usage examples
 - **[Tests](tests/)** - Test suites and usage patterns

exonware_xwnode-0.0.1.23.dist-info/RECORD

@@ -0,0 +1,130 @@
+exonware/__init__.py,sha256=lcEri_z9es5NKYsnFWVkitU70TRFzBpehNPQ6jntvtc,624
+exonware/xwnode/__init__.py,sha256=0knJ488CZj01gOIUEGbq1ekxTfBxIMK99RwQkWQ-tGA,4175
+exonware/xwnode/add_strategy_types.py,sha256=f-v7FfOltYylw-65p5HYCuuFoRf64ujzU4DPyXdVqSs,4977
+exonware/xwnode/base.py,sha256=zM2vE55RziwBz_-x0B5GYGOyM0Coi_kEo-meMM59u-A,23895
+exonware/xwnode/config.py,sha256=cJGwxc2FiNH9lw1vslLHOQJ3Xl2DfekKF4h_lnUD-pc,5519
+exonware/xwnode/contracts.py,sha256=s3nMO7hdSvDbonABbQAHgmWsDi_H_P7JdyU6WqYnRWM,17925
+exonware/xwnode/defs.py,sha256=eWjFb0UOCltv90VXwW0e-ijGTHYkdhXmX6yyq17-QXA,47068
+exonware/xwnode/errors.py,sha256=JVS1AgK7wtR_c170UWRPaIqGqVWylc9qpu3JPyT8pNU,18285
+exonware/xwnode/facade.py,sha256=8b3ltkqOfqxpCCpwropwyTVd12CvtnjmDB2w3t9079I,16263
+exonware/xwnode/version.py,sha256=I89UC16bEL-pVH76pSGm_mg0kIIBGlwW-rYqwi2GKng,2379
+exonware/xwnode/common/__init__.py,sha256=MwiQsuW0IJ_vUhWwhcR3okSMyHW2vlOsY5swjq3JIyw,387
+exonware/xwnode/common/graph/__init__.py,sha256=7h8OS_ggwmWys9-1j_Fsg2tlucpr_KKcTYv-jFkvXgs,645
+exonware/xwnode/common/graph/caching.py,sha256=hsAcaZK9towFEItK34HgcrOIrPlJT2l_tEXEx9ga6z4,3575
+exonware/xwnode/common/graph/contracts.py,sha256=In67LQDWbuUy3pt9UOV6RGXh8efN8o-n5TqQzx8sK48,2434
+exonware/xwnode/common/graph/errors.py,sha256=2OVMbCFzYta05PWn0SPZsxr_M1iPFmk1bq3FdflR2r8,857
+exonware/xwnode/common/graph/indexing.py,sha256=POaqQaZ2vb51rcNhnNQdUaToeRnPTGrqr9dB-xiCM9s,8306
+exonware/xwnode/common/graph/manager.py,sha256=nIdZw1o9cgRYfJjqndc9bD2GB3rw8o3bH8KZ1bMBV_0,19875
+exonware/xwnode/common/management/__init__.py,sha256=ixWEyfQ3WS8jG-uwDBlHlTGMhGVPWVfCcKx3SA9HjaY,663
+exonware/xwnode/common/management/manager.py,sha256=rLZgfhsPz6twIO67hRBWEDdkLiYSXC3PoDELcEPNepw,33972
+exonware/xwnode/common/management/migration.py,sha256=lXjg27SuHSF36dRxhL7zq-o0atB0ODdz7Bl3PHvSQDc,20191
+exonware/xwnode/common/monitoring/__init__.py,sha256=nPcol-qnxnSxmcWyDQZt0HKfSxh2FR-VFWuP24wvUw4,663
+exonware/xwnode/common/monitoring/metrics.py,sha256=yiHMmfMSO_CD2v4qGBKm4cVRFDmhGCfAgoDg876DmJc,19556
+exonware/xwnode/common/monitoring/pattern_detector.py,sha256=gxesWUP1OdJdQK_f7VwOxeBW95QVaEkfkg6uUI_KGoc,21668
+exonware/xwnode/common/monitoring/performance_monitor.py,sha256=w26-7IvWjWwydz3ENXdUr-qrI9xGOuLaPLsnKiWoaAM,17579
+exonware/xwnode/common/patterns/__init__.py,sha256=dwPG-LndZhgcVdEnxq1YH5crvxfW4knL1SYl21g9zC4,659
+exonware/xwnode/common/patterns/advisor.py,sha256=RrHRKARK25dwK6dSrOkJeNkMssnJRGW0CMh6KCpGaGQ,18189
+exonware/xwnode/common/patterns/flyweight.py,sha256=W6Mv8vOqvKSQAqM3wl2TbpN22jYv94oJAjr3EE5zGEU,11434
+exonware/xwnode/common/patterns/registry.py,sha256=fi5dZkCTJKqz2KCW16am5WjGEyQefvwYerWLc6wo2b4,29822
+exonware/xwnode/common/utils/__init__.py,sha256=tAI70FC6sfl6lY_KUP-SKDgSiAdvYRawfGavJDso-mg,1464
+exonware/xwnode/common/utils/simple.py,sha256=QN7-kpk73nwPN6vS0Xw54DYKWmcEGPfB9FqTIu2nuRE,9080
+exonware/xwnode/common/utils/utils.py,sha256=ma_C5Xpgpo0053jEWqzco4-KNyBOWanJhKvQ3Masq84,17554
+exonware/xwnode/edges/strategies/__init__.py,sha256=BnDzYc-73WxNc3KTpFmgGSNhQFwlX0X4ujqp-pIj5YM,3249
+exonware/xwnode/edges/strategies/_base_edge.py,sha256=9cgyolEGwmteUJDRltlIvHugDco1_iS1_z5_fadGCYg,13647
+exonware/xwnode/edges/strategies/adj_list.py,sha256=91pzpi1pNxsOAUTRNkFeZ2v-WGvyVaF9_W0tctEJ51k,15676
+exonware/xwnode/edges/strategies/adj_matrix.py,sha256=D8RNDUE_eQvRJ5nLMq-rXgQr6y50Nqdwk0-MHbfO5ts,19247
+exonware/xwnode/edges/strategies/base.py,sha256=QbLcK4O5IpBRxgTnaKp-sjf5PiyfI2b2DLJAJ7vM_t0,6251
+exonware/xwnode/edges/strategies/bidir_wrapper.py,sha256=u5Hi6_K79UncTI7oWR5d_JT_7-yuk6NcJ07PhwCNdwE,19824
+exonware/xwnode/edges/strategies/bitemporal.py,sha256=7ZaLoZFH7zLcu1TkOtSZYcmo8v0u9GBIZtrgtAIdDu4,18460
+exonware/xwnode/edges/strategies/block_adj_matrix.py,sha256=nf64WsXxiqi5t7Bf0wYzrECWuLwIvKe2MG5qrxDSa6s,23778
+exonware/xwnode/edges/strategies/bv_graph.py,sha256=qFN4jovcW-DRK_2XSErXZ7Q9CO1marFlpQn8jWU1bFg,22598
+exonware/xwnode/edges/strategies/compressed_graph.py,sha256=USVk_-XlLpXu5k6U8arusFDJ1G2wE2qjmbsMTTqEHcI,7838
+exonware/xwnode/edges/strategies/coo.py,sha256=8Srn6QgsCOuErRns94kpkmIkWdVMQhsBu7v6vN2TZKE,21605
+exonware/xwnode/edges/strategies/csc.py,sha256=Nt-7Rsh4Dk6M6AOLbRa9rO-6yYYhOaeFfmpMA6NrV44,18435
+exonware/xwnode/edges/strategies/csr.py,sha256=XJOQXsVk2DObdQIdu-VYUq8kBrjB1_excwQA9zwbL8A,22336
+exonware/xwnode/edges/strategies/dynamic_adj_list.py,sha256=mePzSVARy5OdCvWEKGW1W314fDKXHW2tlJz1j1COTB0,21408
+exonware/xwnode/edges/strategies/edge_list.py,sha256=G2vyIawMAJs_NC6ibA05rO0Dc-kAoPhCzU2DIDq9Uvo,5832
+exonware/xwnode/edges/strategies/edge_property_store.py,sha256=oCKthsTZLVkx1TnaCWMnh7uLV14j2TxlN1EMWWW1qIM,25628
+exonware/xwnode/edges/strategies/euler_tour.py,sha256=EnsBv4dKiPS4TF5a6k-EYARGjw1ABf668XQFySsqWw0,18116
+exonware/xwnode/edges/strategies/flow_network.py,sha256=GzaEKc98QTYAa7k7QnXRAPoHCPWkjAQUMziIfxyTvJk,21471
+exonware/xwnode/edges/strategies/graphblas.py,sha256=2y2ZUJHeWcsWQgU61c3_PCvG-qLyzNM5og0mB5pPVWA,15472
+exonware/xwnode/edges/strategies/hnsw.py,sha256=URrifbmfkKU7NmLWGK5T1LT_D4DiXHyAV1fLS5HJiXc,23480
+exonware/xwnode/edges/strategies/hop2_labels.py,sha256=VKdGVRZh_ojc3TEe-70uxIe7t85DM-vd-vr11iV1jiE,16994
+exonware/xwnode/edges/strategies/hyperedge_set.py,sha256=iLHDhEXEKIzFaFOBXsutIyQ49Bzzvb4urqiYqmhsuSY,20762
+exonware/xwnode/edges/strategies/incidence_matrix.py,sha256=3H8RwoFQsnk-XaQk0joZ_T_Fx_fErRO0oAFCBTsO49c,9320
+exonware/xwnode/edges/strategies/k2_tree.py,sha256=eczrr_GrH1OFgqJMvQtUymc8fwTWSQ2xw0xxtBzyYIA,21652
+exonware/xwnode/edges/strategies/link_cut.py,sha256=EMtVRpePkiUzxSqiQPwheKTaMQhz12rIvKCccuYGrLE,20343
+exonware/xwnode/edges/strategies/multiplex.py,sha256=dfjl-Q-yB9_TU6Xu_0RQIlStprMyMoJxjlqbz35IzUI,18641
+exonware/xwnode/edges/strategies/neural_graph.py,sha256=M3tlCOgRH9AnSmz4cuT722FNl2YaBYnlAzmGTHN85kw,25115
+exonware/xwnode/edges/strategies/octree.py,sha256=whjjTOAleqHICjlBsVx6YU6PQbnS2t1rnzukmMHfxxM,25451
+exonware/xwnode/edges/strategies/quadtree.py,sha256=Gb-3a4KIiv7wnwGQwAVdZ2L9dkrCiv_WTVWvzOobO98,22569
+exonware/xwnode/edges/strategies/roaring_adj.py,sha256=cRalgCevNN6xyggaL1Hdoae8VnwWUTnjzTxfGNmEJS4,15786
+exonware/xwnode/edges/strategies/rtree.py,sha256=RiLsJ2ojQjiO9zm9VmCfpzziKbUjcRvZSPqOG6-CDyk,33130
+exonware/xwnode/edges/strategies/temporal_edgeset.py,sha256=JPgpGDZ9J1-9aRnMWtUs8CJpI4pZ0qZ3tntZm2-Gymw,22876
+exonware/xwnode/edges/strategies/tree_graph_basic.py,sha256=izAYfY5M0NKwP5PprVuiqnZMYFzFbbCiKG43MeB2j3Q,12339
+exonware/xwnode/edges/strategies/weighted_graph.py,sha256=CHcQ3pDDIg6SGYXsJ4Cj8hkZyNaXbNJlY4nqGwWLSOc,23334
+exonware/xwnode/nodes/strategies/__init__.py,sha256=gy11-R0C3rp5p5Odq1isIP7BkT2BVVbKwJ11HlhQE0o,1787
+exonware/xwnode/nodes/strategies/adjacency_list.py,sha256=zQv1ly-4BQVG-EPoZ9JsStv7qr45BBaFqCIz0WUiBmY,25245
+exonware/xwnode/nodes/strategies/aho_corasick.py,sha256=nB8WYJvWPX3YUbB2gBfL7YO1evM2LS2zVszC17eWSbk,18673
+exonware/xwnode/nodes/strategies/array_list.py,sha256=rHvj5HfegNDY81oodUYUjWsymey-VNYtIelJb-dd7Eg,8253
+exonware/xwnode/nodes/strategies/art.py,sha256=XXEcZHrsfjpX7jtgL8rVVfUwBSErNYmJLKul9J3Rw18,20637
+exonware/xwnode/nodes/strategies/avl_tree.py,sha256=I1bL6PR5u3qnqUhm-S3JVi-HPdYHWQpAHmjB4dKNqKQ,16261
+exonware/xwnode/nodes/strategies/b_plus_tree.py,sha256=5CntWSprQB61w-dvxeyI592An0xlZE0lI2-J585y6lg,20702
+exonware/xwnode/nodes/strategies/b_tree.py,sha256=_YJ1KzdnL8HcR8bLzKB3aYJapNgDozrraiA4JECMZU0,15154
+exonware/xwnode/nodes/strategies/base.py,sha256=VQgzqxmE5n7SsoiZ5iuOEHqVwmMuaSAD8WkSO6W1Fro,22549
+exonware/xwnode/nodes/strategies/bitmap.py,sha256=b-fcsHVXm35ouqbI0RyWZg5zSjPK8DHLMlqgXAtPNbg,15153
+exonware/xwnode/nodes/strategies/bitset_dynamic.py,sha256=t1sIy0yiV81ifAAbJ5LY6jBhwnrAcGjD4JVyUAt5Ye0,18937
+exonware/xwnode/nodes/strategies/bloom_filter.py,sha256=ly5ZruFr3VC_lCPGeVr-iRwW9tQ81DH7sgteViLuMhI,13749
+exonware/xwnode/nodes/strategies/bloomier_filter.py,sha256=fkg6DThRw1dVeBhpVFp-DKiKl4Zqt3Gejn4Tzt96JZs,17808
+exonware/xwnode/nodes/strategies/bw_tree.py,sha256=F12hLOKnp2jwEndX0-_JdzQ-N00q3yFUB96OXkCNrjY,19576
+exonware/xwnode/nodes/strategies/contracts.py,sha256=BDCfJWGe3u15Q9GKOcVlZWdJws_Kr2MfOhDGzX1FLMQ,3225
+exonware/xwnode/nodes/strategies/count_min_sketch.py,sha256=WHjaVOVOOu8ELMvbqKCLGNkjqDvpAU7IoVhVL-0bqa0,18017
+exonware/xwnode/nodes/strategies/cow_tree.py,sha256=bTRMM_bCoRMv7BCoMBMZcgfR0fperhnRpNmU8ui2lZU,21643
+exonware/xwnode/nodes/strategies/crdt_map.py,sha256=9PR58gxIA4jWKgw1APG5ZVqe-m_9qns32CdOHy341_g,21035
+exonware/xwnode/nodes/strategies/cuckoo_hash.py,sha256=EGBnOH1lPrqUsSZGt3c7gRVzTgxsx-ov1lFitYfWMOI,14950
+exonware/xwnode/nodes/strategies/data_interchange_optimized.py,sha256=5zbiWlCGz2vXctQxWjA9q7LYuxHWaFKOzRIdqbj9eA4,15049
+exonware/xwnode/nodes/strategies/dawg.py,sha256=jx-vAXbIpM-S5APLN6_JF6Rzg-M37dhrMx5VVbp7rpU,28126
+exonware/xwnode/nodes/strategies/deque.py,sha256=FGRGIVU8UMsRMVjyiLcR-TQgh0rtEpoHjGzeXOpQPr0,11866
+exonware/xwnode/nodes/strategies/extendible_hash.py,sha256=AwJbHykpcOZuU2vVeZChYl_Ms9R2LSDj7Q2OniVbQek,2858
+exonware/xwnode/nodes/strategies/fenwick_tree.py,sha256=Y7LpZsbxYAJ6f08QpmfHafk5Rrah4pzHcPrQR7muyOo,14520
+exonware/xwnode/nodes/strategies/hamt.py,sha256=F_4UNSmRVHODe8StwzbeA3VjcMWxHM4JFyrp4kAJgcE,14052
+exonware/xwnode/nodes/strategies/hash_map.py,sha256=yAhZdU50qTfWQWFua04uyURv40qVYvtLDCq_VUSEVa4,13408
+exonware/xwnode/nodes/strategies/heap.py,sha256=Id3339pnmYUn_Dh_VWtr9hP251AXoZGQY59mFer1SQc,13567
+exonware/xwnode/nodes/strategies/hopscotch_hash.py,sha256=tff1XgwWGcpGB91tYFHRvuH1s4--LgNW_2DRSjWGv2k,17650
+exonware/xwnode/nodes/strategies/hyperloglog.py,sha256=cosjsuDEjeXmprnUXhaYwYET2p5WtGPvnH2teJO-984,14997
+exonware/xwnode/nodes/strategies/interval_tree.py,sha256=LL0s4at-RZ-ErFvyQp3BiAAdFBHYcM_qjZQpDulC56w,25276
+exonware/xwnode/nodes/strategies/kd_tree.py,sha256=KB-s0kISkyZ4C3yEs8kXaYcqf6Fi3eUUylYRKP1dP7E,23949
+exonware/xwnode/nodes/strategies/learned_index.py,sha256=JCLmsnf20X_mnG3keE0k9rrAFGsFCqnywLBwDRXlX3Q,19199
+exonware/xwnode/nodes/strategies/linear_hash.py,sha256=t5Ed0x6gvFWx5CzkrUoC9h_NYRcf3368fECEELizhsk,2824
+exonware/xwnode/nodes/strategies/linked_list.py,sha256=yrJx_lo5S6EmZmOxM9fythjou_T9gELC-BE9gYlmRmA,14141
+exonware/xwnode/nodes/strategies/lsm_tree.py,sha256=tlKiZ9IQJQaoovuTjt0rlRuYl6l-t3IJqislCxswQKM,22688
+exonware/xwnode/nodes/strategies/masstree.py,sha256=DxASMwfja0BG3Y_0kMF_JCN3RqXFsDDf_Nk5emBMBmo,4078
+exonware/xwnode/nodes/strategies/ordered_map.py,sha256=XCEx_9C1S7OtIaoM_CqAlDqBNMOGRCg_RMJ1cAmjBz4,14619
+exonware/xwnode/nodes/strategies/ordered_map_balanced.py,sha256=iSS70TiIMapBz3pJxldLwVsfPe5DyDEwxhZJky_2Bps,20601
+exonware/xwnode/nodes/strategies/patricia.py,sha256=0y829h7INJ6J-LmeW3W2pXA88RFq9V1Dae0Z7ct9sDw,18789
+exonware/xwnode/nodes/strategies/persistent_tree.py,sha256=2dZXZ0Yuo55NWGAu6BAiOviYcQgG51UQXy8OOOx26QU,19471
+exonware/xwnode/nodes/strategies/priority_queue.py,sha256=m-X_1JiSCMehe1svJNRNlQtv1V1y_UP3m6MQToH5gVU,22818
+exonware/xwnode/nodes/strategies/queue.py,sha256=2yyG1h0CvNDUZ3R96ARm4RStzqvNj2M5e4GkmGl2BgY,9684
+exonware/xwnode/nodes/strategies/radix_trie.py,sha256=MXTshSaRFC1vQN-ik9ohzCUVU_q5v5CBJnyO03M_M6g,17235
+exonware/xwnode/nodes/strategies/red_black_tree.py,sha256=Pbo4Au3A35Beg4uXlo4p0_Z6xlolnc_PiLwrSEo3mdc,22705
+exonware/xwnode/nodes/strategies/roaring_bitmap.py,sha256=GnqXLDUHQExhmAMVbmLyb48h16ZMS0IlcjFgsDerfMw,20992
+exonware/xwnode/nodes/strategies/rope.py,sha256=nnh7ag8PeFgqtosXP0b8RJdN5sG_Ws5UJ3btTOpUpvA,22886
+exonware/xwnode/nodes/strategies/segment_tree.py,sha256=vg0MGCkK6rvTZZN2seZnTE20RSn5bMioljvnA1CjLKk,10553
+exonware/xwnode/nodes/strategies/set_hash.py,sha256=QtEngD-nOBA8kTiaJ1dJshj7YUtNNiyTYHdN9dPokJU,13402
+exonware/xwnode/nodes/strategies/set_tree.py,sha256=ph6D8jbIlYoCNh_7l8tSHHq_lG8X4hNcYVgP4RfDKbI,15957
+exonware/xwnode/nodes/strategies/skip_list.py,sha256=cH_WK91z3fHWRkUa87fkepjxHxoJFfRBVRj1y4cXpAo,14737
+exonware/xwnode/nodes/strategies/sparse_matrix.py,sha256=bAqmRRk534IDJ_NkLGXoyFEhGBIBI1msSOmCQifstCk,17468
+exonware/xwnode/nodes/strategies/splay_tree.py,sha256=09XL2_Mw9oB3EikpQHGvfcEvdM3RCf3ZqRel-O6ZA8E,15158
+exonware/xwnode/nodes/strategies/stack.py,sha256=GUAes4V3ss8htfSjMoTdWB9zcqveYjfBe_Qosy6pFxo,9789
+exonware/xwnode/nodes/strategies/suffix_array.py,sha256=OOR-tKHfupLpJV8whW3jvLHGzD-swEADXXHaTvKt9So,17139
+exonware/xwnode/nodes/strategies/t_tree.py,sha256=CzpxH14xgKPDCEuUiZEZZA8E29pjo2Nkzt6w9rBaUXg,2863
+exonware/xwnode/nodes/strategies/treap.py,sha256=8jcrzwYn87rS850UcofWq6mmeeS9DpZwvVq9nlbJAc4,17252
+exonware/xwnode/nodes/strategies/tree_graph_hybrid.py,sha256=hzwt3XXSW3HR8qQE6LgOSCaai5YBiLlOxS2CAGkE7r0,55462
+exonware/xwnode/nodes/strategies/trie.py,sha256=5SxaV9rHylqUG_HPu5tTrEo_ysftntZl2DSDChmwcNA,13752
+exonware/xwnode/nodes/strategies/union_find.py,sha256=V0QNfVNMf20-F3ylTmMyoMEYw8ZKUiuUFA_P_Fxk_7E,13583
+exonware/xwnode/nodes/strategies/veb_tree.py,sha256=t4OPKFau5eWYCqWx9536BV1F5bd4kg18CHvdASKCgog,27014
+exonware/xwnode/strategies/__init__.py,sha256=84OCH2moHfFC964SvgWWrV37CnchHyLXaOhJ9yi6ff8,5521
+exonware_xwnode-0.0.1.23.dist-info/METADATA,sha256=N1h62VqMo5FFmlJnjnDxLOrWsuoZIKdcqJP_XCR7TI4,7491
+exonware_xwnode-0.0.1.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+exonware_xwnode-0.0.1.23.dist-info/licenses/LICENSE,sha256=w42ohoEUfhyT0NgiivAL4fWg2AMRLGnfXPMAR4EO-MU,1094
+exonware_xwnode-0.0.1.23.dist-info/RECORD,,

exonware/xwnode/edges/strategies/edge_adj_list.py

@@ -1,353 +0,0 @@
-"""
-Adjacency List Edge Strategy Implementation
-
-This module implements the ADJ_LIST strategy for sparse graph representation
-with efficient edge addition and neighbor queries.
-"""
-
-from typing import Any, Iterator, Dict, List, Set, Optional, Tuple
-from collections import defaultdict
-from ._base_edge import aEdgeStrategy
-from ...defs import EdgeMode, EdgeTrait
-
-
-class xAdjListStrategy(aEdgeStrategy):
-    """
-    Adjacency List edge strategy for sparse graph representation.
-    
-    Provides O(1) edge addition and O(degree) neighbor queries,
-    ideal for sparse graphs where most vertices have few connections.
-    """
-    
-    def __init__(self, traits: EdgeTrait = EdgeTrait.NONE, **options):
-        """Initialize the Adjacency List strategy."""
-        super().__init__(EdgeMode.ADJ_LIST, traits, **options)
-        
-        self.is_directed = options.get('directed', True)
-        self.allow_self_loops = options.get('self_loops', True)
-        self.allow_multi_edges = options.get('multi_edges', False)
-        
-        # Core storage: vertex -> list of (neighbor, edge_data)
-        self._outgoing: Dict[str, List[Tuple[str, Dict[str, Any]]]] = defaultdict(list)
-        self._incoming: Dict[str, List[Tuple[str, Dict[str, Any]]]] = defaultdict(list) if self.is_directed else None
-        
-        # Vertex set for fast membership testing
-        self._vertices: Set[str] = set()
-        
-        # Edge properties storage
-        self._edge_count = 0
-        self._edge_id_counter = 0
-    
-    def get_supported_traits(self) -> EdgeTrait:
-        """Get the traits supported by the adjacency list strategy."""
-        return (EdgeTrait.SPARSE | EdgeTrait.DIRECTED | EdgeTrait.WEIGHTED | EdgeTrait.MULTI)
-    
-    # ============================================================================
-    # CORE EDGE OPERATIONS
-    # ============================================================================
-    
-    def add_edge(self, source: str, target: str, **properties) -> str:
-        """Add an edge between source and target vertices."""
-        # Validate self-loops
-        if source == target and not self.allow_self_loops:
-            raise ValueError(f"Self-loops not allowed: {source} -> {target}")
-        
-        # Check for existing edge if multi-edges not allowed
-        if not self.allow_multi_edges and self.has_edge(source, target):
-            raise ValueError(f"Multi-edges not allowed: {source} -> {target}")
-        
-        # Generate edge ID
-        edge_id = f"edge_{self._edge_id_counter}"
-        self._edge_id_counter += 1
-        
-        # Create edge data
-        edge_data = {
-            'id': edge_id,
-            'source': source,
-            'target': target,
-            'properties': properties.copy()
-        }
-        
-        # Add vertices to vertex set
-        self._vertices.add(source)
-        self._vertices.add(target)
-        
-        # Add to outgoing adjacency list
-        self._outgoing[source].append((target, edge_data))
-        
-        # Add to incoming adjacency list (if directed)
-        if self.is_directed and self._incoming is not None:
-            self._incoming[target].append((source, edge_data))
-        elif not self.is_directed:
-            # For undirected graphs, add reverse edge (unless it's a self-loop)
-            if source != target:
-                self._outgoing[target].append((source, edge_data))
-        
-        self._edge_count += 1
-        return edge_id
-    
-    def remove_edge(self, source: str, target: str, edge_id: Optional[str] = None) -> bool:
-        """Remove edge(s) between source and target."""
-        if source not in self._outgoing:
-            return False
-        
-        removed = False
-        
-        # Remove from outgoing list
-        original_length = len(self._outgoing[source])
-        if edge_id:
-            # Remove specific edge by ID
-            self._outgoing[source] = [
-                (neighbor, data) for neighbor, data in self._outgoing[source]
-                if not (neighbor == target and data['id'] == edge_id)
-            ]
-        else:
-            # Remove all edges to target
-            self._outgoing[source] = [
-                (neighbor, data) for neighbor, data in self._outgoing[source]
-                if neighbor != target
-            ]
-        
-        removed = len(self._outgoing[source]) < original_length
-        
-        if removed:
-            self._edge_count -= (original_length - len(self._outgoing[source]))
-        
-        # Remove from incoming list (if directed)
-        if self.is_directed and self._incoming is not None and target in self._incoming:
-            if edge_id:
-                self._incoming[target] = [
-                    (neighbor, data) for neighbor, data in self._incoming[target]
-                    if not (neighbor == source and data['id'] == edge_id)
-                ]
-            else:
-                self._incoming[target] = [
-                    (neighbor, data) for neighbor, data in self._incoming[target]
-                    if neighbor != source
-                ]
-        elif not self.is_directed and source != target:
-            # For undirected graphs, remove reverse edge
-            if target in self._outgoing:
-                if edge_id:
-                    self._outgoing[target] = [
-                        (neighbor, data) for neighbor, data in self._outgoing[target]
-                        if not (neighbor == source and data['id'] == edge_id)
-                    ]
-                else:
-                    self._outgoing[target] = [
-                        (neighbor, data) for neighbor, data in self._outgoing[target]
-                        if neighbor != source
-                    ]
-        
-        return removed
-    
-    def has_edge(self, source: str, target: str) -> bool:
-        """Check if edge exists between source and target."""
-        if source not in self._outgoing:
-            return False
-        
-        return any(neighbor == target for neighbor, _ in self._outgoing[source])
-    
-    def get_edge_data(self, source: str, target: str) -> Optional[Dict[str, Any]]:
-        """Get edge data between source and target."""
-        if source not in self._outgoing:
-            return None
-        
-        for neighbor, data in self._outgoing[source]:
-            if neighbor == target:
-                return data
-        
-        return None
-    
-    def neighbors(self, vertex: str, direction: str = 'out') -> Iterator[str]:
-        """Get neighbors of a vertex."""
-        if direction == 'out':
-            if vertex in self._outgoing:
-                for neighbor, _ in self._outgoing[vertex]:
-                    yield neighbor
-        elif direction == 'in':
-            if self.is_directed and self._incoming is not None and vertex in self._incoming:
-                for neighbor, _ in self._incoming[vertex]:
-                    yield neighbor
-            elif not self.is_directed:
-                # For undirected graphs, incoming = outgoing
-                if vertex in self._outgoing:
-                    for neighbor, _ in self._outgoing[vertex]:
-                        yield neighbor
-        elif direction == 'both':
-            # Get all neighbors (both in and out)
-            seen = set()
-            for neighbor in self.neighbors(vertex, 'out'):
-                if neighbor not in seen:
-                    seen.add(neighbor)
-                    yield neighbor
-            for neighbor in self.neighbors(vertex, 'in'):
-                if neighbor not in seen:
-                    seen.add(neighbor)
-                    yield neighbor
-    
-    def degree(self, vertex: str, direction: str = 'out') -> int:
-        """Get degree of a vertex."""
-        if direction == 'out':
-            return len(self._outgoing.get(vertex, []))
-        elif direction == 'in':
-            if self.is_directed and self._incoming is not None:
-                return len(self._incoming.get(vertex, []))
-            elif not self.is_directed:
-                return len(self._outgoing.get(vertex, []))
-            else:
-                return 0
-        elif direction == 'both':
-            out_degree = self.degree(vertex, 'out')
-            in_degree = self.degree(vertex, 'in')
-            # For undirected graphs, avoid double counting
-            return out_degree if not self.is_directed else out_degree + in_degree
-    
-    def edges(self, data: bool = False) -> Iterator[tuple]:
-        """Get all edges in the graph."""
-        seen_edges = set()
-        
-        for source, adj_list in self._outgoing.items():
-            for target, edge_data in adj_list:
-                edge_key = (source, target, edge_data['id'])
-                
-                if edge_key not in seen_edges:
-                    seen_edges.add(edge_key)
-                    
-                    if data:
-                        yield (source, target, edge_data)
-                    else:
-                        yield (source, target)
-    
-    def vertices(self) -> Iterator[str]:
-        """Get all vertices in the graph."""
-        return iter(self._vertices)
-    
-    def __len__(self) -> int:
-        """Get the number of edges."""
-        return self._edge_count
-    
-    def vertex_count(self) -> int:
-        """Get the number of vertices."""
-        return len(self._vertices)
-    
-    def clear(self) -> None:
-        """Clear all edges and vertices."""
-        self._outgoing.clear()
-        if self._incoming is not None:
-            self._incoming.clear()
-        self._vertices.clear()
-        self._edge_count = 0
-        self._edge_id_counter = 0
-    
-    def add_vertex(self, vertex: str) -> None:
-        """Add a vertex to the graph."""
-        self._vertices.add(vertex)
-        # Initialize adjacency lists if not present
-        if vertex not in self._outgoing:
-            self._outgoing[vertex] = []
-        if self.is_directed and self._incoming is not None and vertex not in self._incoming:
-            self._incoming[vertex] = []
-    
-    def remove_vertex(self, vertex: str) -> bool:
-        """Remove a vertex and all its edges."""
-        if vertex not in self._vertices:
-            return False
-        
-        # Remove all outgoing edges
-        edges_removed = len(self._outgoing.get(vertex, []))
-        self._edge_count -= edges_removed
-        
-        # Remove all incoming edges
-        for source in list(self._outgoing.keys()):
-            if source != vertex:
-                original_length = len(self._outgoing[source])
-                self._outgoing[source] = [
-                    (neighbor, data) for neighbor, data in self._outgoing[source]
-                    if neighbor != vertex
-                ]
-                self._edge_count -= (original_length - len(self._outgoing[source]))
-        
-        # Clean up adjacency lists
-        if vertex in self._outgoing:
-            del self._outgoing[vertex]
-        if self._incoming is not None and vertex in self._incoming:
-            del self._incoming[vertex]
-        
-        # Remove from vertex set
-        self._vertices.remove(vertex)
-        
-        return True
-    
-    # ============================================================================
-    # ADVANCED OPERATIONS
-    # ============================================================================
-    
-    def get_subgraph(self, vertices: Set[str]) -> 'xAdjListStrategy':
-        """Extract subgraph containing only specified vertices."""
-        subgraph = xAdjListStrategy(
-            traits=self._traits,
-            directed=self.is_directed,
-            self_loops=self.allow_self_loops,
-            multi_edges=self.allow_multi_edges
-        )
-        
-        # Add vertices
-        for vertex in vertices:
-            if vertex in self._vertices:
-                subgraph.add_vertex(vertex)
-        
-        # Add edges
-        for source, target, edge_data in self.edges(data=True):
-            if source in vertices and target in vertices:
-                subgraph.add_edge(source, target, **edge_data['properties'])
-        
-        return subgraph
-    
-    def get_edge_list(self) -> List[Tuple[str, str, Dict[str, Any]]]:
-        """Get all edges as a list."""
-        return list(self.edges(data=True))
-    
-    def get_adjacency_dict(self) -> Dict[str, List[str]]:
-        """Get adjacency representation as a dictionary."""
-        return {
-            vertex: [neighbor for neighbor, _ in adj_list]
-            for vertex, adj_list in self._outgoing.items()
-        }
-    
-    # ============================================================================
-    # PERFORMANCE CHARACTERISTICS
-    # ============================================================================
-    
-    @property
-    def backend_info(self) -> Dict[str, Any]:
-        """Get backend implementation info."""
-        return {
-            'strategy': 'adjacency_list',
-            'backend': 'Python defaultdict + lists',
-            'directed': self.is_directed,
-            'multi_edges': self.allow_multi_edges,
-            'self_loops': self.allow_self_loops,
-            'complexity': {
-                'add_edge': 'O(1)',
-                'remove_edge': 'O(degree)',
-                'has_edge': 'O(degree)',
-                'neighbors': 'O(degree)',
-                'space': 'O(V + E)'
-            }
-        }
-    
-    @property
-    def metrics(self) -> Dict[str, Any]:
-        """Get performance metrics."""
-        avg_degree = self._edge_count / max(1, len(self._vertices)) if self._vertices else 0
-        density = self._edge_count / max(1, len(self._vertices) * (len(self._vertices) - 1)) if len(self._vertices) > 1 else 0
-        
-        return {
-            'vertices': len(self._vertices),
-            'edges': self._edge_count,
-            'average_degree': round(avg_degree, 2),
-            'density': round(density, 4),
-            'memory_usage': f"{len(self._vertices) * 48 + self._edge_count * 32} bytes (estimated)",
-            'sparsity': f"{(1 - density) * 100:.1f}%"
-        }