Change names from btree to larch.

25 files changed, 202 insertions, 202 deletions

diff --git a/codec-speed b/codec-speed
index 3ef8178..e383f85 100755
--- a/codec-speed
+++ b/codec-speed
@@ -19,7 +19,7 @@ import cProfile
 import sys
 import time
 
-import btree
+import larch
 
 
 def measure(n, unit_size, func, do_profile, profname):
@@ -58,7 +58,7 @@ def main():
     value_size = 128
     node_size = 64*1024
 
-    codec = btree.NodeCodec(key_size)
+    codec = larch.NodeCodec(key_size)
 
     key_fmt = '%%0%dd' % key_size
     keys = [key_fmt % i for i in range(n)]
@@ -67,10 +67,10 @@ def main():
     leaf_values = [value_fmt % i for i in range(n)]
     index_values = range(n)
 
-    leaf = btree.LeafNode(42, keys, leaf_values)
+    leaf = larch.LeafNode(42, keys, leaf_values)
     encoded_leaf = codec.encode_leaf(leaf)
 
-    index = btree.IndexNode(42, keys, index_values)
+    index = larch.IndexNode(42, keys, index_values)
     encoded_index = codec.encode_index(index)
 
     # Measure and report.
diff --git a/debian/control b/debian/control
index 7c543e1..ef72af5 100644
--- a/debian/control
+++ b/debian/control
@@ -1,4 +1,4 @@
-Source: python-btree
+Source: python-larch
 Maintainer: Lars Wirzenius <liw@liw.fi>
 Section: python
 Priority: optional
@@ -8,11 +8,11 @@ Build-Depends: debhelper (>= 7.3.8), python-support (>= 1.0.3),
     python-coverage-test-runner, python-tracing
 XS-Python-Version: >= 2.5
 
-Package: python-btree
+Package: python-larch
 Architecture: all
 Depends: ${python:Depends}, ${misc:Depends}, python (>= 2.5), 
     python-lru (>= 0.4), python-tracing
 XB-Python-Version: ${python:Versions}
 Description: B-tree library for Python
- The btree Python library implements the copy-on-write B-trees designed by
+ The larch Python library implements the copy-on-write B-trees designed by
  Odah Rodeh.
diff --git a/debian/copyright b/debian/copyright
index 224409b..2594a62 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -1,7 +1,7 @@
 Format-Specification: http://svn.debian.org/wsvn/dep/web/deps/dep5.mdwn?op=file&rev=135
-Name: btree
+Name: larch
 Maintainer: Lars Wirzenius <liw@liw.fi>
-Source: http://code.liw.fi/btree/bzr/trunk/
+Source: http://code.liw.fi/larch/bzr/trunk/
 
 Files: *
 Copyright: 2010, Lars Wirzenius
diff --git a/debian/rules b/debian/rules
index b5dbaec..341cbe2 100755
--- a/debian/rules
+++ b/debian/rules
@@ -7,4 +7,4 @@ override_dh_auto_build:
 	dh_auto_build $@ --with-buildsystem=python_distutils
 
 override_dh_auto_install:
-	python setup.py install --prefix=debian/python-btree/usr
+	python setup.py install --prefix=debian/python-larch/usr
diff --git a/example.py b/example.py
index 3b34196..53864c9 100644
--- a/example.py
+++ b/example.py
@@ -18,7 +18,7 @@ import hashlib
 import os
 import sys
 
-import btree
+import larch
 
 
 def compute(filename):
@@ -37,7 +37,7 @@ def open_tree(dirname):
     key_size = len(compute('/dev/null'))
     node_size = 4096
     
-    forest = btree.open_forest(key_size=key_size, node_size=node_size,
+    forest = larch.open_forest(key_size=key_size, node_size=node_size,
                                dirname=dirname)
     if forest.trees:
         tree = forest.trees[0]
diff --git a/fsck-larch b/fsck-larch
index c7b50b0..30351b5 100755
--- a/fsck-larch
+++ b/fsck-larch
@@ -19,7 +19,7 @@ import logging
 import sys
 import ttystatus
 
-import btree
+import larch
 
 
 class BtreeFsck(object):
@@ -31,8 +31,8 @@ class BtreeFsck(object):
         self.dirname = dirname
         self.node_size = node_size
         self.key_size = key_size
-        codec = btree.NodeCodec(key_size)
-        self.ns = btree.NodeStoreDisk(node_size, codec, dirname=dirname)
+        codec = larch.NodeCodec(key_size)
+        self.ns = larch.NodeStoreDisk(node_size, codec, dirname=dirname)
         self.minkey = '\x00' * key_size
         self.maxkey = '\xff' * key_size
 
@@ -87,7 +87,7 @@ class BtreeFsck(object):
         child0_id = node[keys[0]]
         try:
             child0 = self.ns.get_node(child0_id)
-        except btree.NodeMissing:
+        except larch.NodeMissing:
             self.error('child missing: %d' % child0_id)
             self.error('index node not checked: %d' % node.id)
             return
@@ -96,7 +96,7 @@ class BtreeFsck(object):
         for key in keys:
             child = self.ns.get_node(node[key])
             
-            self.assert_in(type(child), [btree.IndexNode, btree.LeafNode],
+            self.assert_in(type(child), [larch.IndexNode, larch.LeafNode],
                            'type must be index or leaf')
             self.assert_equal(type(child), child_type,
                               'all children must have same type')
@@ -104,21 +104,21 @@ class BtreeFsck(object):
     def check_root_node(self, root):
         self.assert_equal(self.ns.get_refcount(root.id), 1, 
                           'root refcount should be 1')
-        self.assert_equal(type(root), btree.IndexNode, 'root must be an index')
+        self.assert_equal(type(root), larch.IndexNode, 'root must be an index')
         
     def walk(self, node, minkey, maxkey):
         if node.id in self.checked:
             return
         self.checked.add(node.id)
         yield node, minkey, maxkey
-        if type(node) is btree.IndexNode:
+        if type(node) is larch.IndexNode:
             keys = node.keys()
             next_keys = keys[1:] + [maxkey]
             for i in range(len(keys)):
                 child_id = node[keys[i]]
                 try:
                     child = self.ns.get_node(child_id)
-                except btree.NodeMissing:
+                except larch.NodeMissing:
                     self.error('node missing: %d' % child_id)
                 else:
                     for t in self.walk(child, keys[i], next_keys[i]):
@@ -127,7 +127,7 @@ class BtreeFsck(object):
     def check_tree(self, root_id):
         try:
             root = self.ns.get_node(root_id)
-        except btree.NodeMissing:
+        except larch.NodeMissing:
             self.error('root node missing: %d' % root_id)
         else:
             self.check_root_node(root)
@@ -135,7 +135,7 @@ class BtreeFsck(object):
                 self.status['node_id'] = str(node.id)
                 self.status['nodes_done'] += 1
                 self.check_node(node, min2, max2)
-                if type(node) is btree.IndexNode:
+                if type(node) is larch.IndexNode:
                     self.check_index_node(node, min2, max2)
                 else:
                     self.check_leaf_node(node, min2, max2)
@@ -145,7 +145,7 @@ class BtreeFsck(object):
         return [int(x) for x in string.split(',')]
 
     def check_forest(self):
-        self.info('btree fsck')
+        self.info('larch fsck')
         self.info('forest: %s' % self.dirname)
         self.info('node size: %d' % self.node_size)
         self.info('key size: %d' % self.key_size)
@@ -169,7 +169,7 @@ def main():
     node_size = 65535 # doesn't matter for reading
     key_size = int(sys.argv[2])
     
-    logging.basicConfig(filename='fsck-btree.log', level=logging.DEBUG)
+    logging.basicConfig(filename='fsck-larch.log', level=logging.DEBUG)
     
     ts = ttystatus.TerminalStatus(period=0.1)
     ts.add(ttystatus.Literal('checking nodes '))
diff --git a/larch/codec.py b/larch/codec.py
index b8476c4..be4d5e6 100644
--- a/larch/codec.py
+++ b/larch/codec.py
@@ -16,7 +16,7 @@
 
 import struct
 
-import btree
+import larch
 
 
 class CodecError(Exception):
@@ -82,7 +82,7 @@ class NodeCodec(object):
         for length in lengths:
             append(encoded[offset:offset + length])
             offset += length
-        return btree.LeafNode(node_id, keys, values)
+        return larch.LeafNode(node_id, keys, values)
 
     def max_index_pairs(self, node_size):
         '''Return number of index pairs that fit in a node of a given size.'''
@@ -116,10 +116,10 @@ class NodeCodec(object):
         assert len(keys) == len(child_ids)
         for x in child_ids:
             assert type(x) == int
-        return btree.IndexNode(node_id, keys, child_ids)
+        return larch.IndexNode(node_id, keys, child_ids)
 
     def encode(self, node):
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             return self.encode_leaf(node)
         else:
             return self.encode_index(node)
@@ -136,7 +136,7 @@ class NodeCodec(object):
     def size(self, node):
         keys = node.keys()
         values = node.values()
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             return self.leaf_size(keys, values)
         else:
             return self.index_size(keys, values)
diff --git a/larch/codec_tests.py b/larch/codec_tests.py
index 9bc0ccd..77a2d06 100644
--- a/larch/codec_tests.py
+++ b/larch/codec_tests.py
@@ -16,15 +16,15 @@
 
 import unittest
 
-import btree
+import larch
 
 
 class NodeCodecTests(unittest.TestCase):
 
     def setUp(self):
-        self.leaf = btree.LeafNode(1234, ['foo', 'yoo'], ['bar', 'yoyo'])
-        self.index = btree.IndexNode(5678, ['bar', 'foo'], [1234, 7890])
-        self.codec = btree.NodeCodec(3)
+        self.leaf = larch.LeafNode(1234, ['foo', 'yoo'], ['bar', 'yoyo'])
+        self.index = larch.IndexNode(5678, ['bar', 'foo'], [1234, 7890])
+        self.codec = larch.NodeCodec(3)
 
     def test_returns_reasonable_size_for_empty_leaf(self):
         self.assert_(self.codec.leaf_size([], []) > 10)
@@ -33,11 +33,11 @@ class NodeCodecTests(unittest.TestCase):
         self.assert_(self.codec.index_size([], []) > 10)
 
     def test_returns_reasonable_size_for_empty_leaf_generic(self):
-        leaf = btree.LeafNode(0, [], [])
+        leaf = larch.LeafNode(0, [], [])
         self.assert_(self.codec.size(leaf) > 10)
 
     def test_returns_reasonable_size_for_empty_index_generic(self):
-        index = btree.IndexNode(0, [], [])
+        index = larch.IndexNode(0, [], [])
         self.assert_(self.codec.size(index) > 10)
 
     def test_leaf_round_trip_ok(self):
@@ -61,13 +61,13 @@ class NodeCodecTests(unittest.TestCase):
         self.assertEqual(self.codec.decode(encoded), self.index)
 
     def test_decode_leaf_raises_error_for_garbage(self):
-        self.assertRaises(btree.CodecError, self.codec.decode_leaf, 'x'*1000)
+        self.assertRaises(larch.CodecError, self.codec.decode_leaf, 'x'*1000)
 
     def test_decode_index_raises_error_for_garbage(self):
-        self.assertRaises(btree.CodecError, self.codec.decode_index, 'x'*1000)
+        self.assertRaises(larch.CodecError, self.codec.decode_index, 'x'*1000)
 
     def test_decode_raises_error_for_garbage(self):
-        self.assertRaises(btree.CodecError, self.codec.decode, 'x'*1000)
+        self.assertRaises(larch.CodecError, self.codec.decode, 'x'*1000)
     
     def test_returns_resonable_max_number_of_index_pairs(self):
         # Header is 16 bytes. A pair is key_bytes + 8 = 11.
diff --git a/larch/forest.py b/larch/forest.py
index d66816a..eae31fc 100644
--- a/larch/forest.py
+++ b/larch/forest.py
@@ -14,7 +14,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-import btree
+import larch
 
 
 class BadKeySize(Exception):
@@ -55,7 +55,7 @@ class Forest(object):
             s = self.node_store.get_metadata('root_ids')
             if s.strip():
                 root_ids = [int(x) for x in s.split(',')]
-                self.trees = [btree.BTree(self, self.node_store, root_id)
+                self.trees = [larch.BTree(self, self.node_store, root_id)
                               for root_id in root_ids]
             else:
                 self.trees = []
@@ -80,7 +80,7 @@ class Forest(object):
         else:
             keys = []
             values = []
-        t = btree.BTree(self, self.node_store, None)
+        t = larch.BTree(self, self.node_store, None)
         t.set_root(t.new_index(keys, values))
         self.trees.append(t)
         return t
@@ -111,8 +111,8 @@ def open_forest(key_size=None, node_size=None, codec=None, node_store=None,
     
     key_size, node_size must be given with every call.
     codec is the class to be used for the node codec, defaults to
-    btree.NodeCodec. Similarly, node_store is the node store class,
-    defaults to btree.NodeStoreDisk.
+    larch.NodeCodec. Similarly, node_store is the node store class,
+    defaults to larch.NodeStoreDisk.
     
     All other keyword arguments are given the thoe node_store
     class initializer.
@@ -122,8 +122,8 @@ def open_forest(key_size=None, node_size=None, codec=None, node_store=None,
     assert key_size is not None
     assert node_size is not None
 
-    codec = codec or btree.NodeCodec
-    node_store = node_store or btree.NodeStoreDisk
+    codec = codec or larch.NodeCodec
+    node_store = node_store or larch.NodeStoreDisk
 
     c = codec(key_size)
     ns = node_store(node_size, c, **kwargs)
diff --git a/larch/forest_tests.py b/larch/forest_tests.py
index cc976b3..922c314 100644
--- a/larch/forest_tests.py
+++ b/larch/forest_tests.py
@@ -18,15 +18,15 @@ import shutil
 import tempfile
 import unittest
 
-import btree
+import larch
 
 
 class ForestTests(unittest.TestCase):
 
     def setUp(self):
-        self.codec = btree.NodeCodec(3)
-        self.ns = btree.NodeStoreMemory(64, self.codec)
-        self.forest = btree.Forest(self.ns)
+        self.codec = larch.NodeCodec(3)
+        self.ns = larch.NodeStoreMemory(64, self.codec)
+        self.forest = larch.Forest(self.ns)
 
     def test_new_node_ids_grow(self):
         id1 = self.forest.new_id()
@@ -38,7 +38,7 @@ class ForestTests(unittest.TestCase):
 
     def test_creates_a_tree(self):
         t = self.forest.new_tree()
-        self.assert_(isinstance(t, btree.BTree))
+        self.assert_(isinstance(t, larch.BTree))
         self.assertEqual(self.forest.trees, [t])
 
     def test_clones_a_tree(self):
@@ -64,7 +64,7 @@ class ForestTests(unittest.TestCase):
         t1.insert('foo', 'bar')
         self.forest.commit()
 
-        f2 = btree.Forest(self.ns)
+        f2 = larch.Forest(self.ns)
         self.assertEqual([t.root.id for t in f2.trees], [t1.root.id])
 
     def test_removes_trees(self):
@@ -89,7 +89,7 @@ class ForestTests(unittest.TestCase):
         t2.remove('000')
         self.forest.commit()
 
-        f2 = btree.Forest(self.ns)
+        f2 = larch.Forest(self.ns)
         t1a, t2a = f2.trees
         self.assertEqual(t1.root.id, t1a.root.id)
         self.assertEqual(t2.root.id, t2a.root.id)
@@ -111,7 +111,7 @@ class ForestTests(unittest.TestCase):
         self.forest.remove_tree(t1)
         self.forest.commit()
 
-        f2 = btree.Forest(self.ns)
+        f2 = larch.Forest(self.ns)
         self.assertEqual(f2.trees, [])
 
     def test_commit_puts_key_and_node_sizes_in_metadata(self):
@@ -131,39 +131,39 @@ class OpenForestTests(unittest.TestCase):
         shutil.rmtree(self.tempdir)
         
     def test_creates_new_forest(self):
-        f = btree.open_forest(key_size=self.key_size, node_size=self.node_size,
+        f = larch.open_forest(key_size=self.key_size, node_size=self.node_size,
                               dirname=self.tempdir)
         self.assertEqual(f.node_store.codec.key_bytes, self.key_size)
         self.assertEqual(f.node_store.node_size, self.node_size)
 
     def test_fail_if_existing_tree_has_incompatible_key_size(self):
-        f = btree.open_forest(key_size=self.key_size, node_size=self.node_size,
+        f = larch.open_forest(key_size=self.key_size, node_size=self.node_size,
                               dirname=self.tempdir)
         f.commit()
         
-        self.assertRaises(btree.BadKeySize, 
-                          btree.open_forest,
+        self.assertRaises(larch.BadKeySize, 
+                          larch.open_forest,
                           key_size=self.key_size + 1, 
                           node_size=self.node_size,
                           dirname=self.tempdir)
 
     def test_fail_if_existing_tree_has_incompatible_node_size(self):
-        f = btree.open_forest(key_size=self.key_size, node_size=self.node_size,
+        f = larch.open_forest(key_size=self.key_size, node_size=self.node_size,
                               dirname=self.tempdir)
         f.commit()
         
-        self.assertRaises(btree.BadNodeSize, 
-                          btree.open_forest,
+        self.assertRaises(larch.BadNodeSize, 
+                          larch.open_forest,
                           key_size=self.key_size, 
                           node_size=self.node_size + 1,
                           dirname=self.tempdir)
 
     def test_opens_existing_tree_with_compatible_key_and_node_size(self):
-        f = btree.open_forest(key_size=self.key_size, node_size=self.node_size,
+        f = larch.open_forest(key_size=self.key_size, node_size=self.node_size,
                               dirname=self.tempdir)
         f.commit()
         
-        f2 = btree.open_forest(key_size=self.key_size, 
+        f2 = larch.open_forest(key_size=self.key_size, 
                                node_size=self.node_size,
                                dirname=self.tempdir)
                                
@@ -173,7 +173,7 @@ class OpenForestTests(unittest.TestCase):
 class BadKeySizeTests(unittest.TestCase):
 
     def test_both_sizes_in_error_message(self):
-        e = btree.BadKeySize(123, 456)
+        e = larch.BadKeySize(123, 456)
         self.assert_('123' in str(e))
         self.assert_('456' in str(e))
 
@@ -181,7 +181,7 @@ class BadKeySizeTests(unittest.TestCase):
 class BadNodeSizeTests(unittest.TestCase):
 
     def test_both_sizes_in_error_message(self):
-        e = btree.BadNodeSize(123, 456)
+        e = larch.BadNodeSize(123, 456)
         self.assert_('123' in str(e))
         self.assert_('456' in str(e))
 
diff --git a/larch/nodes.py b/larch/nodes.py
index 6b4f765..87c6811 100644
--- a/larch/nodes.py
+++ b/larch/nodes.py
@@ -16,7 +16,7 @@
 
 import bisect
 
-import btree
+import larch
 
 
 class FrozenNode(Exception):
diff --git a/larch/nodes_tests.py b/larch/nodes_tests.py
index 579c6e3..168fcba 100644
--- a/larch/nodes_tests.py
+++ b/larch/nodes_tests.py
@@ -16,14 +16,14 @@
 
 import unittest
 
-import btree
+import larch
 
 
 class FrozenNodeTests(unittest.TestCase):
 
     def test_node_id_is_in_error_message(self):
-        node = btree.nodes.Node(123, [], [])
-        e = btree.FrozenNode(node)
+        node = larch.nodes.Node(123, [], [])
+        e = larch.FrozenNode(node)
         self.assert_('123' in str(e))
 
 
@@ -35,7 +35,7 @@ class NodeTests(unittest.TestCase):
         self.pairs.sort()
         self.keys = [k for k, v in self.pairs]
         self.values = [v for k, v in self.pairs]
-        self.node = btree.nodes.Node(self.node_id, self.keys, self.values)
+        self.node = larch.nodes.Node(self.node_id, self.keys, self.values)
 
     def test_has_id(self):
         self.assertEqual(self.node.id, self.node_id)
@@ -85,48 +85,48 @@ class NodeTests(unittest.TestCase):
         self.assertEqual(self.node.values(), self.values)
 
     def test_adds_key_value_pair_to_empty_node(self):
-        node = btree.nodes.Node(0, [], [])
+        node = larch.nodes.Node(0, [], [])
         node.add('foo', 'bar')
         self.assertEqual(node.keys(), ['foo'])
         self.assertEqual(node.values(), ['bar'])
         self.assertEqual(node['foo'], 'bar')
 
     def test_adds_key_value_pair_to_end_of_node_of_one_element(self):
-        node = btree.nodes.Node(0, ['foo'], ['bar'])
+        node = larch.nodes.Node(0, ['foo'], ['bar'])
         node.add('foo2', 'bar2')
         self.assertEqual(node.keys(), ['foo', 'foo2'])
         self.assertEqual(node.values(), ['bar', 'bar2'])
         self.assertEqual(node['foo2'], 'bar2')
 
     def test_adds_key_value_pair_to_beginning_of_node_of_one_element(self):
-        node = btree.nodes.Node(0, ['foo'], ['bar'])
+        node = larch.nodes.Node(0, ['foo'], ['bar'])
         node.add('bar', 'bar')
         self.assertEqual(node.keys(), ['bar', 'foo'])
         self.assertEqual(node.values(), ['bar', 'bar'])
         self.assertEqual(node['bar'], 'bar')
 
     def test_adds_key_value_pair_to_middle_of_node_of_two_elements(self):
-        node = btree.nodes.Node(0, ['bar', 'foo'], ['bar', 'bar'])
+        node = larch.nodes.Node(0, ['bar', 'foo'], ['bar', 'bar'])
         node.add('duh', 'bar')
         self.assertEqual(node.keys(), ['bar', 'duh', 'foo'])
         self.assertEqual(node.values(), ['bar', 'bar', 'bar'])
         self.assertEqual(node['duh'], 'bar')
 
     def test_add_replaces_value_for_existing_key(self):
-        node = btree.nodes.Node(0, ['bar', 'foo'], ['bar', 'bar'])
+        node = larch.nodes.Node(0, ['bar', 'foo'], ['bar', 'bar'])
         node.add('bar', 'xxx')
         self.assertEqual(node.keys(), ['bar', 'foo'])
         self.assertEqual(node.values(), ['xxx', 'bar'])
         self.assertEqual(node['bar'], 'xxx')
 
     def test_add_resets_cached_size(self):
-        node = btree.nodes.Node(0, [], [])
+        node = larch.nodes.Node(0, [], [])
         node.size = 1234
         node.add('foo', 'bar')
         self.assertEqual(node.size, None)
 
     def test_removes_first_key(self):
-        node = btree.nodes.Node(0, ['bar', 'duh', 'foo'], 
+        node = larch.nodes.Node(0, ['bar', 'duh', 'foo'], 
                                    ['bar', 'bar', 'bar'])
         node.remove('bar')
         self.assertEqual(node.keys(), ['duh', 'foo'])
@@ -134,7 +134,7 @@ class NodeTests(unittest.TestCase):
         self.assertRaises(KeyError, node.__getitem__, 'bar')
 
     def test_removes_last_key(self):
-        node = btree.nodes.Node(0, ['bar', 'duh', 'foo'], 
+        node = larch.nodes.Node(0, ['bar', 'duh', 'foo'], 
                                    ['bar', 'bar', 'bar'])
         node.remove('foo')
         self.assertEqual(node.keys(), ['bar', 'duh'])
@@ -142,7 +142,7 @@ class NodeTests(unittest.TestCase):
         self.assertRaises(KeyError, node.__getitem__, 'foo')
 
     def test_removes_middle_key(self):
-        node = btree.nodes.Node(0, ['bar', 'duh', 'foo'], 
+        node = larch.nodes.Node(0, ['bar', 'duh', 'foo'], 
                                    ['bar', 'bar', 'bar'])
         node.remove('duh')
         self.assertEqual(node.keys(), ['bar', 'foo'])
@@ -150,18 +150,18 @@ class NodeTests(unittest.TestCase):
         self.assertRaises(KeyError, node.__getitem__, 'duh')
 
     def test_raises_exception_when_removing_unknown_key(self):
-        node = btree.nodes.Node(0, ['bar', 'duh', 'foo'], 
+        node = larch.nodes.Node(0, ['bar', 'duh', 'foo'], 
                                    ['bar', 'bar', 'bar'])
         self.assertRaises(KeyError, node.remove, 'yo')
 
     def test_remove_resets_cached_size(self):
-        node = btree.nodes.Node(0, ['foo'], ['bar'])
+        node = larch.nodes.Node(0, ['foo'], ['bar'])
         node.size = 1234
         node.remove('foo')
         self.assertEqual(node.size, None)
 
     def test_removes_index_range(self):
-        node = btree.nodes.Node(0, ['bar', 'duh', 'foo'], 
+        node = larch.nodes.Node(0, ['bar', 'duh', 'foo'], 
                                    ['bar', 'bar', 'bar'])
         node.size = 12375654
         node.remove_index_range(1, 5)
@@ -174,7 +174,7 @@ class NodeTests(unittest.TestCase):
         # every combination of minkey and maxkey being less than, equal,
         # or greater than either child key (as long as minkey <= maxkey).
         
-        node = btree.LeafNode(0, ['bar', 'foo'], ['bar', 'foo']) 
+        node = larch.LeafNode(0, ['bar', 'foo'], ['bar', 'foo']) 
         find = node.find_keys_in_range
 
         self.assertEqual(find('aaa', 'aaa'), [])
@@ -198,7 +198,7 @@ class NodeTests(unittest.TestCase):
         self.assertEqual(find('ggg', 'ggg'), [])
 
     def test_finds_no_potential_range_in_empty_node(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.assertEqual(node.find_potential_range('aaa', 'bbb'), (None, None))
 
     def test_finds_potential_ranges(self):
@@ -206,7 +206,7 @@ class NodeTests(unittest.TestCase):
         # every combination of minkey and maxkey being less than, equal,
         # or greater than either child key (as long as minkey <= maxkey).
         
-        node = btree.LeafNode(0, ['bar', 'foo'], ['bar', 'foo'])
+        node = larch.LeafNode(0, ['bar', 'foo'], ['bar', 'foo'])
         find = node.find_potential_range
 
         self.assertEqual(find('aaa', 'aaa'), (None, None))
@@ -237,24 +237,24 @@ class NodeTests(unittest.TestCase):
 
     def test_freezing_makes_add_raise_error(self):
         self.node.frozen = True
-        self.assertRaises(btree.FrozenNode, self.node.add, 'foo', 'bar')
+        self.assertRaises(larch.FrozenNode, self.node.add, 'foo', 'bar')
 
     def test_freezing_makes_remove_raise_error(self):
         self.node.frozen = True
-        self.assertRaises(btree.FrozenNode, self.node.remove, 'foo')
+        self.assertRaises(larch.FrozenNode, self.node.remove, 'foo')
 
     def test_freezing_makes_remove_index_range_raise_error(self):
         self.node.frozen = True
-        self.assertRaises(btree.FrozenNode, self.node.remove_index_range, 0, 1)
+        self.assertRaises(larch.FrozenNode, self.node.remove_index_range, 0, 1)
 
 
 class IndexNodeTests(unittest.TestCase):
 
     def setUp(self):
-        self.leaf1 = btree.LeafNode(0, ['bar'], ['bar'])
-        self.leaf2 = btree.LeafNode(1, ['foo'], ['foo'])
+        self.leaf1 = larch.LeafNode(0, ['bar'], ['bar'])
+        self.leaf2 = larch.LeafNode(1, ['foo'], ['foo'])
         self.index_id = 1234
-        self.index = btree.IndexNode(self.index_id, ['bar', 'foo'],
+        self.index = larch.IndexNode(self.index_id, ['bar', 'foo'],
                                      [self.leaf1.id, self.leaf2.id])
 
 
@@ -271,11 +271,11 @@ class IndexNodeTests(unittest.TestCase):
         self.assertEqual(self.index.find_key_for_child_containing('a'), None)
 
     def test_finds_no_key_when_node_is_empty(self):
-        empty = btree.IndexNode(0, [], [])
+        empty = larch.IndexNode(0, [], [])
         self.assertEqual(empty.find_key_for_child_containing('f00'), None)
 
     def test_finds_no_children_in_range_when_empty(self):
-        empty = btree.IndexNode(0, [], [])
+        empty = larch.IndexNode(0, [], [])
         self.assertEqual(empty.find_children_in_range('bar', 'foo'), [])
 
     def test_finds_children_in_ranges(self):
diff --git a/larch/nodestore.py b/larch/nodestore.py
index 4680c60..74e7152 100644
--- a/larch/nodestore.py
+++ b/larch/nodestore.py
@@ -14,7 +14,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-import btree
+import larch
 
 
 class NodeMissing(Exception): # pragma: no cover
@@ -263,60 +263,60 @@ class NodeStoreTests(object): # pragma: no cover
         self.assertEqual(self.ns.list_nodes(), [])
         
     def test_puts_and_gets_same(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
         self.assertEqualNodes(self.ns.get_node(0), node)
 
     def test_put_freezes_node(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.assert_(node.frozen)
 
     def test_get_freezes_node(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         node2 = self.ns.get_node(0)
         self.assert_(node2.frozen)
 
     def test_node_not_in_store_can_not_be_modified(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.assertFalse(self.ns.can_be_modified(node))
 
     def test_node_with_refcount_0_can_not_be_modified(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.set_refcount(node.id, 0)
         self.assertFalse(self.ns.can_be_modified(node))
 
     def test_node_with_refcount_1_can_be_modified(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.set_refcount(node.id, 1)
         self.assertTrue(self.ns.can_be_modified(node))
 
     def test_node_with_refcount_2_can_not_be_modified(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.set_refcount(node.id, 2)
         self.assertFalse(self.ns.can_be_modified(node))
 
     def test_unfreezes_node_when_modification_starts(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.set_refcount(node.id, 1)
         self.ns.start_modification(node)
         self.assertFalse(node.frozen)
 
     def test_start_modification_on_unmodifiable_node_fails(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.set_refcount(node.id, 2)
         self.assertRaises(NodeCannotBeModified, 
                           self.ns.start_modification, node)
 
     def test_removes_node(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
         self.ns.remove_node(0)
@@ -324,33 +324,33 @@ class NodeStoreTests(object): # pragma: no cover
         self.assertEqual(self.ns.list_nodes(), [])
 
     def test_removes_node_from_upload_queue_if_one_exists(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.remove_node(0)
         self.assertRaises(NodeMissing, self.ns.get_node, 0)
         self.assertEqual(self.ns.list_nodes(), [])
 
     def test_lists_node_zero(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
         node_ids = self.ns.list_nodes()
         self.assertEqual(node_ids, [node.id])
 
     def test_put_allows_to_overwrite_a_node(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
-        node = btree.LeafNode(0, ['foo'], ['bar'])
+        node = larch.LeafNode(0, ['foo'], ['bar'])
         self.ns.put_node(node)
         new = self.ns.get_node(0)
         self.assertEqual(new.keys(), ['foo'])
         self.assertEqual(new.values(), ['bar'])
 
     def test_put_allows_to_overwrite_a_node_after_upload_queue_push(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
-        node = btree.LeafNode(0, ['foo'], ['bar'])
+        node = larch.LeafNode(0, ['foo'], ['bar'])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
         new = self.ns.get_node(0)
diff --git a/larch/nodestore_disk.py b/larch/nodestore_disk.py
index 01ce88f..e8303f7 100644
--- a/larch/nodestore_disk.py
+++ b/larch/nodestore_disk.py
@@ -22,7 +22,7 @@ import StringIO
 import struct
 import tempfile
 
-import btree
+import larch
 
 
 class LocalFS(object):
@@ -59,9 +59,9 @@ class LocalFS(object):
         os.remove(filename)
 
 
-class NodeStoreDisk(btree.NodeStore):
+class NodeStoreDisk(larch.NodeStore):
 
-    '''An implementation of btree.NodeStore API for on-disk storage.
+    '''An implementation of larch.NodeStore API for on-disk storage.
     
     The caller will specify a directory in which the nodes will be stored.
     Each node is stored in its own file, named after the node identifier.
@@ -77,14 +77,14 @@ class NodeStoreDisk(btree.NodeStore):
     def __init__(self, node_size, codec, dirname=None, upload_max=1024, 
                  lru_size=100, vfs=None):
         assert dirname is not None
-        btree.NodeStore.__init__(self, node_size, codec)
+        larch.NodeStore.__init__(self, node_size, codec)
         self.dirname = dirname
         self.metadata_name = os.path.join(dirname, 'metadata')
         self.metadata = None
-        self.rs = btree.RefcountStore(self)
+        self.rs = larch.RefcountStore(self)
         self.cache = lru.LRUCache(lru_size)
         self.upload_max = upload_max
-        self.upload_queue = btree.UploadQueue(self._really_put_node, 
+        self.upload_queue = larch.UploadQueue(self._really_put_node, 
                                               self.upload_max)
         self.vfs = vfs if vfs != None else LocalFS()
 
@@ -142,7 +142,7 @@ class NodeStoreDisk(btree.NodeStore):
     def _really_put_node(self, node):
         encoded_node = self.codec.encode(node)
         if len(encoded_node) > self.node_size:
-            raise btree.NodeTooBig(node, len(encoded_node))
+            raise larch.NodeTooBig(node, len(encoded_node))
         name = self.pathname(node.id)
         if self.vfs.exists(name):
             self.vfs.remove(name)
@@ -168,11 +168,11 @@ class NodeStoreDisk(btree.NodeStore):
             self.cache.add(node.id, node)
             return node
         else:
-            raise btree.NodeMissing(node_id)
+            raise larch.NodeMissing(node_id)
 
     def start_modification(self, node):
         if not self.can_be_modified(node):
-            raise btree.NodeCannotBeModified(node.id)
+            raise larch.NodeCannotBeModified(node.id)
         self.upload_queue.remove(node.id)
         node.frozen = False
     
@@ -183,7 +183,7 @@ class NodeStoreDisk(btree.NodeStore):
         if self.vfs.exists(name):
             self.vfs.remove(name)
         elif not got_it:
-            raise btree.NodeMissing(node_id)
+            raise larch.NodeMissing(node_id)
         
     def list_nodes(self):
         queued = self.upload_queue.list_ids()
diff --git a/larch/nodestore_disk_tests.py b/larch/nodestore_disk_tests.py
index 63d54bc..8da2063 100644
--- a/larch/nodestore_disk_tests.py
+++ b/larch/nodestore_disk_tests.py
@@ -20,15 +20,15 @@ import shutil
 import tempfile
 import unittest
 
-import btree
+import larch
 import nodestore_disk
 
 
-class NodeStoreDiskTests(unittest.TestCase, btree.NodeStoreTests):
+class NodeStoreDiskTests(unittest.TestCase, larch.NodeStoreTests):
 
     def setUp(self):
         self.node_size = 4096
-        self.codec = btree.NodeCodec(self.key_bytes)
+        self.codec = larch.NodeCodec(self.key_bytes)
         self.tempdir = tempfile.mkdtemp()
         self.ns = self.new_ns()
 
@@ -59,14 +59,14 @@ class NodeStoreDiskTests(unittest.TestCase, btree.NodeStoreTests):
         self.assertEqual(ns2.get_refcount(0), 1234)
 
     def test_put_refuses_too_large_a_node(self):
-        node = btree.LeafNode(0, ['000'], ['x' * (self.node_size + 1)])
+        node = larch.LeafNode(0, ['000'], ['x' * (self.node_size + 1)])
         def helper(node):
             self.ns.put_node(node)
             self.ns.push_upload_queue()
-        self.assertRaises(btree.NodeTooBig, helper, node)
+        self.assertRaises(larch.NodeTooBig, helper, node)
         
     def test_puts_and_gets_same_with_cache_emptied(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.cache = lru.LRUCache(100)
         self.assertEqualNodes(self.ns.get_node(0), node)
@@ -76,7 +76,7 @@ class NodeStoreDiskTests(unittest.TestCase, btree.NodeStoreTests):
         self.ns.upload_queue.max = self.ns.upload_max
         ids = range(self.ns.upload_max + 1)
         for i in ids:
-            node = btree.LeafNode(i, [], [])
+            node = larch.LeafNode(i, [], [])
             self.ns.put_node(node)
         self.assertEqual(sorted(self.ns.list_nodes()), ids)
         for node_id in ids:
@@ -84,7 +84,7 @@ class NodeStoreDiskTests(unittest.TestCase, btree.NodeStoreTests):
             self.assertEqual(self.ns.get_node(node_id).id, node_id)
             
     def test_gets_node_from_disk(self):
-        node = btree.LeafNode(0, [], [])
+        node = larch.LeafNode(0, [], [])
         self.ns.put_node(node)
         self.ns.push_upload_queue()
         ns2 = self.new_ns()
diff --git a/larch/nodestore_memory.py b/larch/nodestore_memory.py
index c582eeb..3169daa 100644
--- a/larch/nodestore_memory.py
+++ b/larch/nodestore_memory.py
@@ -14,12 +14,12 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-import btree
+import larch
 
 
-class NodeStoreMemory(btree.NodeStore):
+class NodeStoreMemory(larch.NodeStore):
 
-    '''An implementation of btree.NodeStore API for in-memory storage.
+    '''An implementation of larch.NodeStore API for in-memory storage.
     
     All nodes are kept in memory. This is for demonstration and testing
     purposes only.
@@ -27,7 +27,7 @@ class NodeStoreMemory(btree.NodeStore):
     '''
     
     def __init__(self, node_size, codec):
-        btree.NodeStore.__init__(self, node_size, codec)
+        larch.NodeStore.__init__(self, node_size, codec)
         self.nodes = dict()
         self.refcounts = dict()
         self.metadata = dict()
@@ -52,18 +52,18 @@ class NodeStoreMemory(btree.NodeStore):
         if node_id in self.nodes:
             return self.nodes[node_id]
         else:
-            raise btree.NodeMissing(node_id)
+            raise larch.NodeMissing(node_id)
 
     def start_modification(self, node):
         if not self.can_be_modified(node):
-            raise btree.NodeCannotBeModified(node.id)
+            raise larch.NodeCannotBeModified(node.id)
         node.frozen = False
     
     def remove_node(self, node_id):
         if node_id in self.nodes:
             del self.nodes[node_id]
         else:
-            raise btree.NodeMissing(node_id)
+            raise larch.NodeMissing(node_id)
         
     def list_nodes(self):
         return self.nodes.keys()
diff --git a/larch/nodestore_memory_tests.py b/larch/nodestore_memory_tests.py
index 4c691be..eecb905 100644
--- a/larch/nodestore_memory_tests.py
+++ b/larch/nodestore_memory_tests.py
@@ -16,14 +16,14 @@
 
 import unittest
 
-import btree
+import larch
 import nodestore_memory
 
 
-class NodeStoreMemoryTests(unittest.TestCase, btree.NodeStoreTests):
+class NodeStoreMemoryTests(unittest.TestCase, larch.NodeStoreTests):
 
     def setUp(self):
         self.node_size = 4096
-        self.codec = btree.NodeCodec(self.key_bytes)
+        self.codec = larch.NodeCodec(self.key_bytes)
         self.ns = nodestore_memory.NodeStoreMemory(self.node_size, self.codec)
 
diff --git a/larch/refcountstore.py b/larch/refcountstore.py
index c220125..5aa0d65 100644
--- a/larch/refcountstore.py
+++ b/larch/refcountstore.py
@@ -22,7 +22,7 @@ import StringIO
 import struct
 import tempfile
 
-import btree
+import larch
 
 
 class RefcountStore(object):
diff --git a/larch/refcountstore_tests.py b/larch/refcountstore_tests.py
index fe10a8a..a85285d 100644
--- a/larch/refcountstore_tests.py
+++ b/larch/refcountstore_tests.py
@@ -20,7 +20,7 @@ import shutil
 import tempfile
 import unittest
 
-import btree
+import larch
 import nodestore_disk
 
 
@@ -60,7 +60,7 @@ class RefcountStoreTests(unittest.TestCase):
         shutil.rmtree(self.dirname)
 
     def new_rs(self):
-        return btree.RefcountStore(DummyNodeStore(self.dirname))
+        return larch.RefcountStore(DummyNodeStore(self.dirname))
 
     def test_returns_zero_for_unset_refcount(self):
         self.assertEqual(self.rs.get_refcount(123), 0)
diff --git a/larch/tree.py b/larch/tree.py
index 6c1feaa..4761050 100644
--- a/larch/tree.py
+++ b/larch/tree.py
@@ -17,7 +17,7 @@
 import bisect
 import tracing
 
-import btree
+import larch
 
 
 '''A simple B-tree implementation.'''
@@ -84,13 +84,13 @@ class BTree(object):
     
     def new_leaf(self, keys, values):
         '''Create a new leaf node.'''
-        node = btree.LeafNode(self.new_id(), keys, values)
+        node = larch.LeafNode(self.new_id(), keys, values)
         tracing.trace('id=%s' % node.id)
         return node
         
     def new_index(self, keys, values):
         '''Create a new index node.'''
-        index = btree.IndexNode(self.new_id(), keys, values)
+        index = larch.IndexNode(self.new_id(), keys, values)
         for child_id in values:
             self.increment(child_id)
         tracing.trace('id=%s' % index.id)
@@ -133,14 +133,14 @@ class BTree(object):
         self.check_key_size(key)
 
         node = self.root
-        while isinstance(node, btree.IndexNode):
+        while isinstance(node, larch.IndexNode):
             k = node.find_key_for_child_containing(key)
             # If k is None, then the indexing of node will cause KeyError
             # to be returned, just like we want to. This saves us from
             # having to test for it separately.
             node = self.get_node(node[k])
             
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             return node[key]
 
         raise KeyError(key)
@@ -160,11 +160,11 @@ class BTree(object):
 
     def _lookup_range(self, node_id, minkey, maxkey):
         node = self.get_node(node_id)
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             for key in node.find_keys_in_range(minkey, maxkey):
                 yield key, node[key]
         else:
-            assert isinstance(node, btree.IndexNode)
+            assert isinstance(node, larch.IndexNode)
             result = []
             for child_id in node.find_children_in_range(minkey, maxkey):
                 for pair in self._lookup_range(child_id, minkey, maxkey):
@@ -186,10 +186,10 @@ class BTree(object):
 
     def _range_is_empty(self, node_id, minkey, maxkey):
         node = self.get_node(node_id)
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             return node.find_keys_in_range(minkey, maxkey) == []
         else:
-            assert isinstance(node, btree.IndexNode)
+            assert isinstance(node, larch.IndexNode)
             for child_id in node.find_children_in_range(minkey, maxkey):
                 if not self._range_is_empty(child_id, minkey, maxkey):
                     return False
@@ -201,7 +201,7 @@ class BTree(object):
         if self.node_store.can_be_modified(node):
             self.node_store.start_modification(node)
             new = node
-        elif isinstance(node, btree.IndexNode):
+        elif isinstance(node, larch.IndexNode):
             new = self.new_index(node.keys(), node.values())
         else:
             new = self.new_leaf(node.keys(), node.values())
@@ -241,7 +241,7 @@ class BTree(object):
             # making the tree higher because we must.
             assert len(kids) > 0
             for kid in kids:
-                assert type(kid) == btree.IndexNode
+                assert type(kid) == larch.IndexNode
             if len(kids) == 1:
                 new_root = kids[0]
                 tracing.trace('only one kid: id=%s' % new_root.id)
@@ -272,7 +272,7 @@ class BTree(object):
             child_key = new_index.first_key()
 
         child = self.get_node(new_index[child_key])
-        if isinstance(child, btree.IndexNode):
+        if isinstance(child, larch.IndexNode):
             new_kids = self._insert_into_index(child, key, value)
         else:
             new_kids = self._insert_into_leaf(child, key, value)
@@ -288,7 +288,7 @@ class BTree(object):
             n = len(new_index) / 2
             keys = new_index.keys()[n:]
             values = new_index.values()[n:]
-            new = btree.IndexNode(self.new_id(), keys, values)
+            new = larch.IndexNode(self.new_id(), keys, values)
             tracing.trace('new index node id=%s' % new.id)
             for k in keys:
                 new_index.remove(k)
@@ -375,7 +375,7 @@ class BTree(object):
         new_index = self._shadow(old_index)
         child = self.get_node(new_index[child_key])
         
-        if isinstance(child, btree.IndexNode):
+        if isinstance(child, larch.IndexNode):
             new_kid = self._remove_from_index(child, key)
             new_index.remove(child_key)
             if len(new_kid) > 0:
@@ -385,7 +385,7 @@ class BTree(object):
                     self.decrement(new_kid.id)
             self.decrement(child.id)
         else:
-            assert isinstance(child, btree.LeafNode)
+            assert isinstance(child, larch.LeafNode)
             leaf = self._shadow(child)
             leaf.remove(key)
             self.put_node(leaf)
@@ -506,12 +506,12 @@ class BTree(object):
                 break
 
             child = self.get_node(child_id)
-            if isinstance(child, btree.LeafNode):
+            if isinstance(child, larch.LeafNode):
                 tracing.trace('only child is a leaf node')
                 break
 
             # We can just make the child be the new root node.
-            assert type(child) == btree.IndexNode
+            assert type(child) == larch.IndexNode
             # Prevent child from getting removed when parent's refcount
             # gets decremented. set_root will set the refcount to be 1.
             tracing.trace('setting node %s refcount to 2' % child.id)
@@ -538,7 +538,7 @@ class BTree(object):
             tracing.trace('node %s refcount %s, removing node' % 
                          (node_id, refcount))
             node = self.node_store.get_node(node_id)
-            if isinstance(node, btree.IndexNode):
+            if isinstance(node, larch.IndexNode):
                 tracing.trace('reducing refcounts for children')
                 for child_id in node.values():
                     self.decrement(child_id)
@@ -550,13 +550,13 @@ class BTree(object):
         
         def dumper(node, indent):
             refs = self.node_store.get_refcount(node.id)
-            if isinstance(node, btree.IndexNode):
+            if isinstance(node, larch.IndexNode):
                 f.write('%*sindex (id=%d, refs=%d)\n' % (indent*2, '', node.id, refs))
                 for key in node:
                     child = self.get_node(node[key])
                     dumper(child, indent + 1)
             else:
-                assert isinstance(node, btree.LeafNode)
+                assert isinstance(node, larch.LeafNode)
                 f.write('%*sleaf (id=%d, refs=%d, len=%d):' % 
                         (indent*2, '', node.id, refs, len(node)))
                 for key in node:
diff --git a/larch/tree_tests.py b/larch/tree_tests.py
index ddabd64..dfd0ce4 100644
--- a/larch/tree_tests.py
+++ b/larch/tree_tests.py
@@ -18,7 +18,7 @@ import random
 import sys
 import unittest
 
-import btree
+import larch
 
 
 class DummyForest(object):
@@ -31,7 +31,7 @@ class DummyForest(object):
         return self.last_id
 
 
-class DummyNodeStore(btree.NodeStoreMemory):
+class DummyNodeStore(larch.NodeStoreMemory):
 
     def find_nodes(self):
         return self.nodes.keys()
@@ -40,7 +40,7 @@ class DummyNodeStore(btree.NodeStoreMemory):
 class KeySizeMismatchTests(unittest.TestCase):
 
     def setUp(self):
-        self.err = btree.KeySizeMismatch('foo', 4)
+        self.err = larch.KeySizeMismatch('foo', 4)
         
     def test_error_message_contains_key(self):
         self.assert_('foo' in str(self.err))
@@ -52,7 +52,7 @@ class KeySizeMismatchTests(unittest.TestCase):
 class ValueTooLargeTests(unittest.TestCase):
 
     def setUp(self):
-        self.err = btree.ValueTooLarge('foobar', 3)
+        self.err = larch.ValueTooLarge('foobar', 3)
         
     def test_error_message_contains_value(self):
         self.assert_('foobar' in str(self.err))
@@ -66,10 +66,10 @@ class BTreeTests(unittest.TestCase):
     def setUp(self):
         # We use a small node size so that all code paths are traversed
         # during testing. Use coverage.py to make sure they do.
-        self.codec = btree.NodeCodec(3)
+        self.codec = larch.NodeCodec(3)
         self.ns = DummyNodeStore(64, self.codec)
         self.forest = DummyForest()
-        self.tree = btree.BTree(self.forest, self.ns, None)
+        self.tree = larch.BTree(self.forest, self.ns, None)
         self.dump = False
 
     def test_shadow_increments_childrens_refcounts(self):
@@ -103,11 +103,11 @@ class BTreeTests(unittest.TestCase):
 
     def test_new_leaf_does_not_put_node_into_store(self):
         leaf = self.tree.new_leaf([], [])
-        self.assertRaises(btree.NodeMissing, self.tree.get_node, leaf.id)
+        self.assertRaises(larch.NodeMissing, self.tree.get_node, leaf.id)
 
     def test_new_index_does_not_put_node_into_store(self):
         index = self.tree.new_index([], [])
-        self.assertRaises(btree.NodeMissing, self.tree.get_node, index.id)
+        self.assertRaises(larch.NodeMissing, self.tree.get_node, index.id)
 
     def test_new_index_increments_childrens_refcounts(self):
         leaf = self.tree.new_leaf([], [])
@@ -127,7 +127,7 @@ class BTreeTests(unittest.TestCase):
         self.assertRaises(KeyError, self.tree.lookup, 'foo')
 
     def test_lookup_with_wrong_size_key_raises_error(self):
-        self.assertRaises(btree.KeySizeMismatch, self.tree.lookup, '')
+        self.assertRaises(larch.KeySizeMismatch, self.tree.lookup, '')
 
     def test_insert_inserts_key(self):
         self.tree.insert('foo', 'bar')
@@ -143,10 +143,10 @@ class BTreeTests(unittest.TestCase):
         self.assertEqual(self.tree.lookup('foo'), 'bar')
 
     def test_insert_with_wrong_size_key_raises_error(self):
-        self.assertRaises(btree.KeySizeMismatch, self.tree.insert, '', '')
+        self.assertRaises(larch.KeySizeMismatch, self.tree.insert, '', '')
 
     def test_insert_with_too_large_value_raises_error(self):
-        self.assertRaises(btree.ValueTooLarge, self.tree.insert, 'xxx', 
+        self.assertRaises(larch.ValueTooLarge, self.tree.insert, 'xxx', 
                           'x' * (self.ns.max_value_size + 1))
 
     def test_remove_from_empty_tree_raises_keyerror(self):
@@ -167,11 +167,11 @@ class BTreeTests(unittest.TestCase):
         return self.ns.get_node(child_id)
         
     def test_remove_with_wrong_size_key_raises_error(self):
-        self.assertRaises(btree.KeySizeMismatch, self.tree.remove, '')
+        self.assertRaises(larch.KeySizeMismatch, self.tree.remove, '')
 
     def keys_are_in_range(self, node, lower, upper, level=0):
         indent = 2
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             if self.dump:
                 print '%*sleaf keys %s' % (level*indent, '', node.keys())
             for key in node.keys():
@@ -195,7 +195,7 @@ class BTreeTests(unittest.TestCase):
         return True
 
     def find_largest_key(self, node):
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             return max(node.keys())
         else:
             return max(node.keys() + 
@@ -276,13 +276,13 @@ class BTreeTests(unittest.TestCase):
         if not self.dump:
             return
         indent = 4
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             f.write('%*sLeaf:' % (level*indent, ''))
             for key in node.keys():
                 f.write(' %s=%s' % (key, node[key]))
             f.write('\n')
         else:
-            assert isinstance(node, btree.IndexNode)
+            assert isinstance(node, larch.IndexNode)
             f.write('%*sIndex:\n' % (level*indent, ''))
             for key in node.keys():
                 f.write('%*s%s:\n' % ((level+1)*indent, '', key))
@@ -326,13 +326,13 @@ class BTreeTests(unittest.TestCase):
         
     def test_persists(self):
         self.tree.insert('foo', 'bar')
-        tree2 = btree.BTree(self.forest, self.ns, self.tree.root.id)
+        tree2 = larch.BTree(self.forest, self.ns, self.tree.root.id)
         self.assertEqual(tree2.lookup('foo'), 'bar')
 
     def test_last_node_id_persists(self):
         self.tree.insert('foo', 'bar') # make tree has root
         node1 = self.tree.new_leaf([], [])
-        tree2 = btree.BTree(self.forest, self.ns, self.tree.root.id)
+        tree2 = larch.BTree(self.forest, self.ns, self.tree.root.id)
         node2 = tree2.new_leaf([], [])
         self.assertEqual(node1.id + 1, node2.id)
 
@@ -519,10 +519,10 @@ class BTreeDecrementTests(unittest.TestCase):
     def setUp(self):
         # We use a small node size so that all code paths are traversed
         # during testing. Use coverage.py to make sure they do.
-        self.codec = btree.NodeCodec(3)
+        self.codec = larch.NodeCodec(3)
         self.ns = DummyNodeStore(64, self.codec)
         self.forest = DummyForest()
-        self.tree = btree.BTree(self.forest, self.ns, None)
+        self.tree = larch.BTree(self.forest, self.ns, None)
         self.tree.insert('foo', 'bar')
         
     def test_store_has_two_nodes(self):
@@ -545,19 +545,19 @@ class BTreeDecrementTests(unittest.TestCase):
 class BTreeBalanceTests(unittest.TestCase):
 
     def setUp(self):
-        ns = DummyNodeStore(4096, btree.NodeCodec(2))
+        ns = DummyNodeStore(4096, larch.NodeCodec(2))
         forest = DummyForest()
-        self.tree = btree.BTree(forest, ns, None)
+        self.tree = larch.BTree(forest, ns, None)
         self.keys = ['%02d' % i for i in range(10)]
         self.depth = None
 
     def leaves_at_same_depth(self, node, depth=0):
-        if isinstance(node, btree.LeafNode):
+        if isinstance(node, larch.LeafNode):
             if self.depth is None:
                 self.depth = depth
             return self.depth == depth
         else:
-            assert isinstance(node, btree.IndexNode)
+            assert isinstance(node, larch.IndexNode)
             for key in node:
                 child = self.tree.get_node(node[key])
                 if not self.leaves_at_same_depth(child, depth + 1):
@@ -565,7 +565,7 @@ class BTreeBalanceTests(unittest.TestCase):
             return True
             
     def indexes_filled_right_amount(self, node, isroot=True):
-        if isinstance(node, btree.IndexNode):
+        if isinstance(node, larch.IndexNode):
             if not isroot:
                 if len(node) < self.fanout or len(node) > 2 * self.fanout + 1:
                     return False
diff --git a/larch/uploadqueue.py b/larch/uploadqueue.py
index 6f24fa5..338b4c4 100644
--- a/larch/uploadqueue.py
+++ b/larch/uploadqueue.py
@@ -22,7 +22,7 @@ import StringIO
 import struct
 import tempfile
 
-import btree
+import larch
 
 
 class UploadQueue(object):
diff --git a/larch/uploadqueue_tests.py b/larch/uploadqueue_tests.py
index 3ed3c57..8faecb5 100644
--- a/larch/uploadqueue_tests.py
+++ b/larch/uploadqueue_tests.py
@@ -20,7 +20,7 @@ import shutil
 import tempfile
 import unittest
 
-import btree
+import larch
 import nodestore_disk
 
 
@@ -29,8 +29,8 @@ class UploadQueueTests(unittest.TestCase):
     def setUp(self):
         self.max_queue = 2
         self.nodes = []
-        self.uq = btree.UploadQueue(self.really_put, self.max_queue)
-        self.node = btree.LeafNode(1, [], [])
+        self.uq = larch.UploadQueue(self.really_put, self.max_queue)
+        self.node = larch.LeafNode(1, [], [])
 
     def really_put(self, node):
         self.nodes.append(node)
@@ -47,7 +47,7 @@ class UploadQueueTests(unittest.TestCase):
         self.assertEqual(self.uq.get(self.node.id), self.node)
         
     def test_put_replaces_existing_node(self):
-        node2 = btree.LeafNode(1, ['foo'], ['bar'])
+        node2 = larch.LeafNode(1, ['foo'], ['bar'])
         self.uq.put(self.node)
         self.uq.put(node2)
         self.assertEqual(self.uq.get(self.node.id), node2)
@@ -67,20 +67,20 @@ class UploadQueueTests(unittest.TestCase):
 
     def test_does_not_push_second_node(self):
         self.uq.put(self.node)
-        self.uq.put(btree.LeafNode(2, [], []))
+        self.uq.put(larch.LeafNode(2, [], []))
         self.assertEqual(self.nodes, [])
 
     def test_pushes_first_node_after_third_is_pushed(self):
         self.uq.put(self.node)
-        self.uq.put(btree.LeafNode(2, [], []))
-        self.uq.put(btree.LeafNode(3, [], []))
+        self.uq.put(larch.LeafNode(2, [], []))
+        self.uq.put(larch.LeafNode(3, [], []))
         self.assertEqual(self.nodes, [self.node])
 
     def test_pushes_oldest_even_if_recently_used(self):
         self.uq.put(self.node)
-        self.uq.put(btree.LeafNode(2, [], []))
+        self.uq.put(larch.LeafNode(2, [], []))
         self.uq.get(self.node.id)
-        self.uq.put(btree.LeafNode(3, [], []))
+        self.uq.put(larch.LeafNode(3, [], []))
         self.assertEqual(self.nodes, [self.node])
 
     def test_pushes_out_only_node_when_requested(self):
diff --git a/setup.py b/setup.py
index f552156..40ea2c6 100644
--- a/setup.py
+++ b/setup.py
@@ -16,14 +16,14 @@
 
 from distutils.core import setup
 
-import btree
+import larch
 
 setup(
-    name='btree',
-    version=btree.version,
+    name='larch',
+    version=larch.version,
     description='B-tree data structure',
     author='Lars Wirzenius',
     author_email='liw@liw.fi',
-    url='http://liw.fi/btree/',
-    packages=['btree'],
+    url='http://liw.fi/larch/',
+    packages=['larch'],
 )
diff --git a/without-tests b/without-tests
index f6e84a3..c415abf 100644
--- a/without-tests
+++ b/without-tests
@@ -1,4 +1,4 @@
-./btree/__init__.py
-./btree/nodestore.py
+./larch/__init__.py
+./larch/nodestore.py
 ./setup.py
 ./example.py