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

exonware_xwnode-0.0.1.24.dist-info/RECORD

@@ -0,0 +1,130 @@
+exonware/__init__.py,sha256=OLPn37Tlk7pXfSLGOQkrheQjg_M6V9ecIDbAR1BhYeo,624
+exonware/xwnode/__init__.py,sha256=eZeiAWLQopVse7trEEt2s8ixLAUcZbp2KKVSLw1kna8,4175
+exonware/xwnode/add_strategy_types.py,sha256=NGgzbLKZTZdFaC326TFp7NwHtEvBVwIhTZokIzNY68A,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=MxglZnKG9TE1N6X3F9O4HwIF5-jSQjL_oiG_c5-1PLY,16263
+exonware/xwnode/version.py,sha256=1bAacoFMdjL8dzJB0mydgRNkGu6vzCouU_SuL4W-nsQ,2379
+exonware/xwnode/common/__init__.py,sha256=ayCJdi2CxbI5W-m-sRbmIdKaqIcYY35SIJiU-ALqsB4,387
+exonware/xwnode/common/graph/__init__.py,sha256=SR1bJ3uEvupWNMvIKv9Z7_LXTNLxplnb74uo6oCQyzk,645
+exonware/xwnode/common/graph/caching.py,sha256=7epURZDo_ma5jXWAkTVEP4fzLeOM4EFSYaYhYnd-2vI,3575
+exonware/xwnode/common/graph/contracts.py,sha256=Rxsp7kVaZJRqb5pz3nhf_hVouR9LTUxba4T3Zr7ZYP4,2434
+exonware/xwnode/common/graph/errors.py,sha256=kas54Z_kTbcD8vP3n-8fikAIzeffogdhIcEh_MSgMcQ,857
+exonware/xwnode/common/graph/indexing.py,sha256=5cvaulHAO-tR0zn4VDxnDSZ0soN0mBa3WyhJxWgEFQY,8306
+exonware/xwnode/common/graph/manager.py,sha256=R_4IYusKj0sdZUV2wnzFZFnAVvKRfHqILbhKIcrIrBo,19875
+exonware/xwnode/common/management/__init__.py,sha256=7hl5F4roCxtQBNUsHJ8pLiCBLNpvFNceBv1Xnegv8WU,663
+exonware/xwnode/common/management/manager.py,sha256=xi0KqWQZIieYl8r7v2H3Bq8k9fJ-aKs3u59raXEI5AI,33972
+exonware/xwnode/common/management/migration.py,sha256=lXjg27SuHSF36dRxhL7zq-o0atB0ODdz7Bl3PHvSQDc,20191
+exonware/xwnode/common/monitoring/__init__.py,sha256=MdvdB7NC9k8hLIPKqrozonv9Znb8FUKMGGhzSbwZLwQ,663
+exonware/xwnode/common/monitoring/metrics.py,sha256=wCIpnpleLGAFdFRbcSIZcoPTRABuJjadOCXys1r3wwc,19556
+exonware/xwnode/common/monitoring/pattern_detector.py,sha256=fSDt_nZ_ZBA8CjQXH1kph1AhpdhOKCzI5GOTl0Up3mQ,21668
+exonware/xwnode/common/monitoring/performance_monitor.py,sha256=QVO9NeOwhoIrjaBbcTwhrOxxT1OnVYwHrIuuViwo7dc,17579
+exonware/xwnode/common/patterns/__init__.py,sha256=HLjCSSit0K269_l1ib5DhN4WmbF2C4k6KWtPpuX1T1o,659
+exonware/xwnode/common/patterns/advisor.py,sha256=RrHRKARK25dwK6dSrOkJeNkMssnJRGW0CMh6KCpGaGQ,18189
+exonware/xwnode/common/patterns/flyweight.py,sha256=pXcJLJtyEbbEvWaFU85jbGJBN9e4Lvk4LG6FCTC51FA,11434
+exonware/xwnode/common/patterns/registry.py,sha256=fi5dZkCTJKqz2KCW16am5WjGEyQefvwYerWLc6wo2b4,29822
+exonware/xwnode/common/utils/__init__.py,sha256=K2RQIjUdZxJCZ5AHOSTD7qe3wFZeyi7nYpcy1Xl6u8s,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=g75QvFSl8BuFV_XSY41Wj5awNd81wFdG3u9wSD3a3ZU,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=ks69Fu6mKhnPPV_W2_XyLu3pGEPnX08b2ErCWg7lbQY,6251
+exonware/xwnode/edges/strategies/bidir_wrapper.py,sha256=u5Hi6_K79UncTI7oWR5d_JT_7-yuk6NcJ07PhwCNdwE,19824
+exonware/xwnode/edges/strategies/bitemporal.py,sha256=iPGpfSF_7xisC-qvn5L53O_jzqQR7QopaIeo3gTBd-I,18460
+exonware/xwnode/edges/strategies/block_adj_matrix.py,sha256=nf64WsXxiqi5t7Bf0wYzrECWuLwIvKe2MG5qrxDSa6s,23778
+exonware/xwnode/edges/strategies/bv_graph.py,sha256=4MZQf3n3oe7GBC7QasR083iBmiju_YwsfU_by0IIvQE,22598
+exonware/xwnode/edges/strategies/compressed_graph.py,sha256=CZTTbyXkEhcj8Jp2Sj9LBo8NpT82AI-2YIoiDLfLcYQ,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=ixIiO8ta4JXOBrn6JeVWQhDW0Z4ajFrchlpXI3mFg40,5832
+exonware/xwnode/edges/strategies/edge_property_store.py,sha256=oCKthsTZLVkx1TnaCWMnh7uLV14j2TxlN1EMWWW1qIM,25628
+exonware/xwnode/edges/strategies/euler_tour.py,sha256=2OwJWVMJajKFS8Gvy-B8Sso9gh8DyBNCp2p69qzptes,18116
+exonware/xwnode/edges/strategies/flow_network.py,sha256=GzaEKc98QTYAa7k7QnXRAPoHCPWkjAQUMziIfxyTvJk,21471
+exonware/xwnode/edges/strategies/graphblas.py,sha256=35LLLCFcU7TeSBKQnnmbPJAkBU769rpcCtHQO_grJes,15472
+exonware/xwnode/edges/strategies/hnsw.py,sha256=WYlP4W40frMYZPL_C0B7cK0hLb9k1vDh2r4nc3khuvE,23480
+exonware/xwnode/edges/strategies/hop2_labels.py,sha256=OxtebruLCMZ8UvoJIveURJ3RfuupFhHhWb_ZDGSFTBY,16994
+exonware/xwnode/edges/strategies/hyperedge_set.py,sha256=iLHDhEXEKIzFaFOBXsutIyQ49Bzzvb4urqiYqmhsuSY,20762
+exonware/xwnode/edges/strategies/incidence_matrix.py,sha256=X5NsbISJf3sFk1xC5ts-xiF1ARk8F3XnFx9VUBbkGBA,9320
+exonware/xwnode/edges/strategies/k2_tree.py,sha256=DVeIeGWVW8LhCVT7bVtcWcXlfWbWwIhCk6vHr2vMhAs,21652
+exonware/xwnode/edges/strategies/link_cut.py,sha256=F09mBYfPrvGOcDppeb7XDx1dhd4VNC83pjv1lXNtshw,20343
+exonware/xwnode/edges/strategies/multiplex.py,sha256=5lLgVF6sYjkgSWztFmxcdh9M8FTIPDD8O_pxanOhQBo,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=dpLBZtteJ9CNDi49oebSy9WsIQ4N0IQQGWEGZEFIgbU,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=skancc02CcAVdaTyX3YBeTK5xKMMrbEhLY-0LTnnJGA,1787
+exonware/xwnode/nodes/strategies/adjacency_list.py,sha256=HffWnZgMOhH2fI67_7H8wK7-h4DTt08slKlhgtfeCb8,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=WZ2Z-I0Dx_4Jpy_AL9E_E2WCJJOCACWXX4ogkIGq8SY,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=dDYBdfJZzke9wlfmZSJSVhyqvCC_xLXPeGaXDEOqc4M,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=tZWuOH5DrmOkYPKq4CPzh11GEvnZdSIshaMCv6qiZPI,13749
+exonware/xwnode/nodes/strategies/bloomier_filter.py,sha256=SrnyNe2U4ONULmUUfs1d7UGKHEG6PTBj3ZSzRqmjnP8,17808
+exonware/xwnode/nodes/strategies/bw_tree.py,sha256=zvD5U1NHJ-HqUsYUGJ6LdSn2AvaSjJn6Yduosx4q9wc,19576
+exonware/xwnode/nodes/strategies/contracts.py,sha256=Q0F041lPyigbjrW35JygtylCQHE7lwhh03YQUqAfSRU,3225
+exonware/xwnode/nodes/strategies/count_min_sketch.py,sha256=WHjaVOVOOu8ELMvbqKCLGNkjqDvpAU7IoVhVL-0bqa0,18017
+exonware/xwnode/nodes/strategies/cow_tree.py,sha256=aOwszgEU734RIEQJiDDCSMplii4OE0NRKt1idC4v1xg,21643
+exonware/xwnode/nodes/strategies/crdt_map.py,sha256=LKDh4RF7_AOAO_USwze4Ckcp3A0CP0AQI7EyJu-4vnA,21035
+exonware/xwnode/nodes/strategies/cuckoo_hash.py,sha256=EGBnOH1lPrqUsSZGt3c7gRVzTgxsx-ov1lFitYfWMOI,14950
+exonware/xwnode/nodes/strategies/data_interchange_optimized.py,sha256=-ewKP2WnS3YTkdWi694Jn4tM5kpK2XnpqjoVBYoZObU,15049
+exonware/xwnode/nodes/strategies/dawg.py,sha256=dz9IEZQhBY1HQT5QYLTTpOtxbeQAJYUF9AoR9b9QrsY,28126
+exonware/xwnode/nodes/strategies/deque.py,sha256=89EJcjrSGDXzt_axMVOnTjItfACm5dwfldYK_QWit-k,11866
+exonware/xwnode/nodes/strategies/extendible_hash.py,sha256=IAk5nOGplK2jJv25PQ-22ZvR3awwpSD4snGeDad4nY4,2858
+exonware/xwnode/nodes/strategies/fenwick_tree.py,sha256=Y7LpZsbxYAJ6f08QpmfHafk5Rrah4pzHcPrQR7muyOo,14520
+exonware/xwnode/nodes/strategies/hamt.py,sha256=aw3ohKJfJNs8bk_C7RPCJO49mAouSJg17u9fF6o7TJk,14052
+exonware/xwnode/nodes/strategies/hash_map.py,sha256=SCPKsy4vqu9irZpUe1NKFi-ipg2nGwu07uv62Ozavw0,13408
+exonware/xwnode/nodes/strategies/heap.py,sha256=Id3339pnmYUn_Dh_VWtr9hP251AXoZGQY59mFer1SQc,13567
+exonware/xwnode/nodes/strategies/hopscotch_hash.py,sha256=49SS3c766PcmsdNNxcg1V5Dx681uf89WUU-ku5XShG4,17650
+exonware/xwnode/nodes/strategies/hyperloglog.py,sha256=cosjsuDEjeXmprnUXhaYwYET2p5WtGPvnH2teJO-984,14997
+exonware/xwnode/nodes/strategies/interval_tree.py,sha256=yl2A55QctiYcxMOo2WFK5eBqK6mGRD-47VWA_svkhTc,25276
+exonware/xwnode/nodes/strategies/kd_tree.py,sha256=4PDWVcV-c6Q_WaO-_2_BXnNfYwRfxgDs7Ig0tMDyzNY,23949
+exonware/xwnode/nodes/strategies/learned_index.py,sha256=PEw8_3Nd9Ki8uu4gXZbNFey6y--LZLMRQyimhdvMBuo,19199
+exonware/xwnode/nodes/strategies/linear_hash.py,sha256=xAEoW8PNJIAtrm0TbUEIbO3tEip6wyh8BDjcPF1uKx0,2824
+exonware/xwnode/nodes/strategies/linked_list.py,sha256=yrJx_lo5S6EmZmOxM9fythjou_T9gELC-BE9gYlmRmA,14141
+exonware/xwnode/nodes/strategies/lsm_tree.py,sha256=1kkpGZ4kP7odHtz-hBBVVwGYL1fkM4sIs5ktMEorzIY,22688
+exonware/xwnode/nodes/strategies/masstree.py,sha256=I5khCJIIQSDX9ZETTiUvQAqa1_VEbAw_WAda3pyXI4g,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=XwMQk8MB0KtBur5NE3uD3MQ24Xri61Kye75gYMg58bQ,19471
+exonware/xwnode/nodes/strategies/priority_queue.py,sha256=YWEiWTb8yvmUiQLEH-erjlZMTOsyfE12F3PyZl7YrR8,22818
+exonware/xwnode/nodes/strategies/queue.py,sha256=knMVblGwgTE8Yj7bW0z_FALyqKDV65OKQlUezXqd0vI,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=7HHRZOu76skDi0MldyX7JxEErBjvMokEdn-TdHB2K04,20992
+exonware/xwnode/nodes/strategies/rope.py,sha256=hk-I_5RHKdWY0T8R5dAJeyCHpBbdPk87zFYb58cKlYM,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=mxV-4usMb9zIx7LHCrqrLdESq-F8DGWkD71n9SJ_Ymk,17468
+exonware/xwnode/nodes/strategies/splay_tree.py,sha256=09XL2_Mw9oB3EikpQHGvfcEvdM3RCf3ZqRel-O6ZA8E,15158
+exonware/xwnode/nodes/strategies/stack.py,sha256=8D-2JO7INb54bo6A3E-KqLTc6_0Yl2VhX2xe7DkRqys,9789
+exonware/xwnode/nodes/strategies/suffix_array.py,sha256=OOR-tKHfupLpJV8whW3jvLHGzD-swEADXXHaTvKt9So,17139
+exonware/xwnode/nodes/strategies/t_tree.py,sha256=6iE7pf943JCVQoGNQrvnozvAWiVh0JCmTX2IhVbA3Q0,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=LVankfrVaMFmO5wzcSxbQysRtk3zc2VdHUTiouuappY,27014
+exonware/xwnode/strategies/__init__.py,sha256=9_OmgETRBSn6-D2hQb9wlBe03QcKMRlJ0hnZLTyVtYw,5521
+exonware_xwnode-0.0.1.24.dist-info/METADATA,sha256=kG8p7K0R1e0lihO2n1zwxmzSb74PvFWK2bCM-xiY5Qs,28317
+exonware_xwnode-0.0.1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+exonware_xwnode-0.0.1.24.dist-info/licenses/LICENSE,sha256=w42ohoEUfhyT0NgiivAL4fWg2AMRLGnfXPMAR4EO-MU,1094
+exonware_xwnode-0.0.1.24.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}%"
-        }