Wrapper around the C extension to provide a consistent API.

Leaf node containing key-value pairs. Leaf nodes are where all actual key-value pairs are stored in a B+ tree. They are linked together to fo

B+ Tree implementation with Python dict-like API. A B+ tree is a self-balancing tree data structure that maintains sorted data and allows sea

Internal (branch) node containing keys and child pointers. Branch nodes guide the search through the tree. They contain separator keys and po

Fuzz tester for B+ Tree with operation tracking and reference comparison

Private class for validating B+ tree invariants. This class encapsulates all the complex logic for checking that a B+ tree maintains its

Leaf node using Python array module for more efficient int storage.

Traditional two-array leaf node for comparison.

Branch node with single array optimization.

Leaf node with single array optimization.

Suite of performance benchmarks.

Raised when an invalid capacity is specified.

B+ Tree with single array node optimization.

Measure baseline performance metrics for B+ tree operations.

Compare B+ Tree and SortedDict performance.

Test that C extension no longer segfaults on large insertions.

Test all dictionary-like methods of BPlusTreeMap.

Test that iterators are invalidated when tree is modified.

Tests to isolate and understand the max occupancy violation bug

Test suite to ensure no segfaults occur.

Stress tests for edge cases that could break B+ tree invariants

Base exception for B+ tree operations.

Result extension trait for improved error handling

Fast iterator over key-value pairs using unsafe arena access for better performance.

Result of an insertion operation on a node.

Iterator over key-value pairs in the B+ tree using the leaf linked list.

Iterator over keys in the B+ tree.

Abstract base class for B+ tree nodes. This class defines the interface that both leaf and branch nodes must implement. All nodes in the B+ t

Optimized iterator over a range of key-value pairs in the B+ tree. Uses tree navigation to find start, then linked list traversal for efficiency.

Result of a removal operation on a node.

Node data that can be allocated in the arena after a split.

Test cases for B+ tree iteration

Test cases for range-based iteration

Test basic B+ tree operations

Test BranchNode operations

Test dictionary API with larger datasets to ensure performance.

Test cases based on patterns discovered during fuzz testing

Stress tests with large datasets.

Test LeafNode operations

Test for memory leaks in various operations.

Test node merging during deletion

Test node underflow detection

Performance benchmark tests with threshold validation.

Compare performance against standard Python dict.

Performance regression tests to ensure consistent performance.

Tests to detect performance regressions.

Test B+ tree removal operations

Test B+ tree operations when splitting nodes

Test sibling key redistribution during deletion

Iterator over values in the B+ tree.