fix some issues with DictStore

Author: alimanfoo

zarr/storage.py

@@ -340,7 +340,10 @@ def __init__(self, cls=dict):
     def __getitem__(self, key):
         c = self.root
         for k in key.split('/'):
-            c = c[k]
+            if isinstance(c, self.cls):
+                c = c[k]
+            else:
+                raise KeyError(key)
         if isinstance(c, self.cls):
             raise KeyError(key)
         return c
@@ -351,35 +354,48 @@ def __setitem__(self, key, value):
 
         # ensure intermediate containers
         for k in keys[:-1]:
-            try:
-                c = c[k]
-                if not isinstance(c, self.cls):
-                    raise KeyError(key)
-            except KeyError:
-                c[k] = self.cls()
-                c = c[k]
+            if isinstance(c, self.cls):
+                try:
+                    c = c[k]
+                except KeyError:
+                    c[k] = self.cls()
+                    c = c[k]
+            else:
+                raise KeyError(key)
 
-        # set final value
-        c[keys[-1]] = value
+        if isinstance(c, self.cls):
+            # set final value
+            c[keys[-1]] = value
+        else:
+            raise KeyError(key)
 
     def __delitem__(self, key):
         c = self.root
         keys = key.split('/')
 
         # obtain final container
         for k in keys[:-1]:
-            c = c[k]
+            if isinstance(c, self.cls):
+                c = c[k]
+            else:
+                raise KeyError(key)
 
-        # delete item
-        del c[keys[-1]]
+        if isinstance(c, self.cls):
+            # delete item
+            del c[keys[-1]]
+        else:
+            raise KeyError(key)
 
     def __contains__(self, key):
         keys = key.split('/')
         c = self.root
         for k in keys:
-            try:
-                c = c[k]
-            except KeyError:
+            if isinstance(c, self.cls):
+                try:
+                    c = c[k]
+                except KeyError:
+                    return False
+            else:
                 return False
         return not isinstance(c, self.cls)
 

zarr/tests/test_hierarchy.py

@@ -187,22 +187,27 @@ def test_create_dataset(self):
         eq('/bar', d3.name)
         assert_is(store, d3.store)
 
-    def test_getitem_contains(self):
+    def test_getitem_contains_iterators(self):
         # setup
         store = self.create_store()
         init_group(store)
         g1 = Group(store=store)
         g2 = g1.create_group('foo/bar')
-        d1 = g1.create_dataset('a/b/c', shape=1000, chunks=100)
+        d1 = g2.create_dataset('/a/b/c', shape=1000, chunks=100)
         d1[:] = np.arange(1000)
+        d2 = g1.create_dataset('foo/baz', shape=3000, chunks=300)
+        d2[:] = np.arange(3000)
 
         # test __getitem__
         assert_is_instance(g1['foo'], Group)
         assert_is_instance(g1['foo']['bar'], Group)
         assert_is_instance(g1['foo/bar'], Group)
         assert_is_instance(g1['/foo/bar/'], Group)
+        assert_is_instance(g1['foo/baz'], Array)
         eq(g2, g1['foo/bar'])
         eq(g1['foo']['bar'], g1['foo/bar'])
+        eq(d2, g1['foo/baz'])
+        assert_array_equal(d2[:], g1['foo/baz'])
         assert_is_instance(g1['a'], Group)
         assert_is_instance(g1['a']['b'], Group)
         assert_is_instance(g1['a/b'], Group)
@@ -215,27 +220,68 @@ def test_getitem_contains(self):
         # test __contains__
         assert 'foo' in g1
         assert 'foo/bar' in g1
+        assert 'foo/baz' in g1
         assert 'bar' in g1['foo']
         assert 'a' in g1
         assert 'a/b' in g1
         assert 'a/b/c' in g1
         assert 'baz' not in g1
         assert 'a/b/c/d' not in g1
         assert 'a/z' not in g1
+        assert 'quux' not in g1['foo']
 
         # test key errors
         with assert_raises(KeyError):
             g1['baz']
         with assert_raises(KeyError):
             g1['x/y/z']
 
+        # test __len__
+        eq(2, len(g1))
+        eq(2, len(g1['foo']))
+        eq(0, len(g1['foo/bar']))
+        eq(1, len(g1['a']))
+        eq(1, len(g1['a/b']))
+
+        # test keys()
+        eq(['a', 'foo'], sorted(g1.keys()))
+        eq(['bar', 'baz'], sorted(g1['foo'].keys()))
+        eq([], sorted(g1['foo/bar'].keys()))
+
+    def test_empty_getitem_contains_iterators(self):
+        # setup
+        store = self.create_store()
+        init_group(store)
+        g = Group(store=store)
+
+        # test
+        eq([], list(g.keys()))
+        eq(0, len(g))
+        assert 'foo' not in g
+
+    def test_group_repr(self):
+        store = self.create_store()
+        init_group(store)
+        g = Group(store=store)
+        expect = 'zarr.hierarchy.Group(/, 0)\n  store: builtins.dict'
+        actual = repr(g)
+        eq(expect, actual)
+
 
 class TestGroupDictStore(TestGroup):
 
     @staticmethod
     def create_store():
         return DictStore()
 
+    def test_group_repr(self):
+        store = self.create_store()
+        init_group(store)
+        g = Group(store=store)
+        expect = 'zarr.hierarchy.Group(/, 0)\n  store: zarr.storage.DictStore'
+        actual = repr(g)
+        eq(expect, actual)
+
 
 def rmtree_if_exists(path, rmtree=shutil.rmtree, isdir=os.path.isdir):
     if isdir(path):
@@ -251,6 +297,15 @@ def create_store():
         store = DirectoryStore(path)
         return store
 
+    def test_group_repr(self):
+        store = self.create_store()
+        init_group(store)
+        g = Group(store=store)
+        expect = 'zarr.hierarchy.Group(/, 0)\n' \
+                 '  store: zarr.storage.DirectoryStore'
+        actual = repr(g)
+        eq(expect, actual)
+
 
 class TestGroupZipStore(TestGroup):
 
@@ -260,3 +315,12 @@ def create_store():
         atexit.register(os.remove, path)
         store = ZipStore(path)
         return store
+
+    def test_group_repr(self):
+        store = self.create_store()
+        init_group(store)
+        g = Group(store=store)
+        expect = 'zarr.hierarchy.Group(/, 0)\n' \
+                 '  store: zarr.storage.ZipStore'
+        actual = repr(g)
+        eq(expect, actual)