diff --git a/cstore/datapackstore.cpp b/cstore/datapackstore.cpp
--- a/cstore/datapackstore.cpp
+++ b/cstore/datapackstore.cpp
@@ -102,7 +102,7 @@
 
 DeltaChainIterator DatapackStore::getDeltaChain(const Key &key) {
   std::shared_ptr<DeltaChain> chain = this->getDeltaChainRaw(key);
-  if (chain->code() == GET_DELTA_CHAIN_OK) {
+  if (chain->status() == GET_DELTA_CHAIN_OK) {
     return DeltaChainIterator(chain);
   }
   throw MissingKeyError("unable to find delta chain");
@@ -125,8 +125,8 @@
       continue;
     }
 
-    // Pass ownership of chain to DeltaChain
-    return std::make_shared<DeltaChain>(chain);
+    // Pass ownership of chain to CDeltaChain
+    return std::make_shared<CDeltaChain>(chain);
   }
 
   // Check if there are new packs available
@@ -147,11 +147,11 @@
       continue;
     }
 
-    // Pass ownership of chain to DeltaChain
-    return std::make_shared<DeltaChain>(chain);
+    // Pass ownership of chain to CDeltaChain
+    return std::make_shared<CDeltaChain>(chain);
   }
 
-  return std::make_shared<DeltaChain>(GET_DELTA_CHAIN_NOT_FOUND);
+  return std::make_shared<CDeltaChain>(GET_DELTA_CHAIN_NOT_FOUND);
 }
 
 Key *DatapackStoreKeyIterator::next() {
diff --git a/cstore/datastore.h b/cstore/datastore.h
--- a/cstore/datastore.h
+++ b/cstore/datastore.h
@@ -10,166 +10,10 @@
 #ifndef FBHGEXT_DATASTORE_H
 #define FBHGEXT_DATASTORE_H
 
-extern "C" {
-#include "cdatapack/cdatapack.h"
-}
-
 #include <memory>
-#include <vector>
-
-#include "cstore/key.h"
-#include "clib/portability/portability.h"
-
-class DeltaChainLink {
-  private:
-    const char *_filename, *_deltabasefilename;
-    const uint8_t *_node, *_deltabasenode, *_delta;
-    uint16_t _filenamesz;
-    uint64_t _deltasz;
-
-  public:
-    DeltaChainLink(delta_chain_link_t *link) {
-      if (link) {
-        _filename = link->filename;
-        _deltabasefilename = link->filename;
-        _node = link->node;
-        _deltabasenode = link->deltabase_node;
-        _delta = link->delta;
-        _filenamesz = link->filename_sz;
-        _deltasz = link->delta_sz;
-      } else {
-        _filename = NULL;
-        _deltabasefilename = NULL;
-        _node = NULL;
-        _deltabasenode = NULL;
-        _delta = NULL;
-        _filenamesz = 0;
-        _deltasz = 0;
-      }
-    }
-
-    const char* filename() {
-      return _filename;
-    }
-
-    const char* deltabasefilename() {
-      return _deltabasefilename;
-    }
-
-    const uint8_t* node() {
-      return _node;
-    }
-
-    const uint8_t* deltabasenode() {
-      return _deltabasenode;
-    }
-
-    const uint8_t* delta() {
-      return _delta;
-    }
-
-    uint16_t filenamesz() {
-      return _filenamesz;
-    }
-
-    uint64_t deltasz() {
-      return _deltasz;
-    }
-
-    bool isdone() {
-      return (_filename == NULL);
-    }
-};
-
-/*
- * This class takes ownership of a delta chain
- */
-class DeltaChain {
-  private:
-    //C DeltaChain
-    delta_chain_t _chain;
 
-  public:
-    //The constructor does a shallow copy of the delta chain and since the
-    //ownership is taken by this class it is responsible for memory management
-    DeltaChain(delta_chain_t chain) : _chain(chain) {}
-
-    DeltaChain(get_delta_chain_code_t error) {
-      _chain = COMPOUND_LITERAL(delta_chain_t) { GET_DELTA_CHAIN_NOT_FOUND };
-    }
-
-    ~DeltaChain() {
-      freedeltachain(_chain);
-    }
-
-    const DeltaChainLink getlink(const size_t idx) {
-      return DeltaChainLink(&(_chain.delta_chain_links[idx]));
-    }
-
-    size_t linkcount() {
-      return _chain.links_count;
-    }
-
-    get_delta_chain_code_t code() {
-      return _chain.code;
-    }
-
-};
-
-class DeltaChainIterator {
-  private:
-    size_t _index;
-  protected:
-    std::vector< std::shared_ptr<DeltaChain> > _chains;
-    DeltaChainIterator() :
-      _index(0) {}
-    virtual std::shared_ptr<DeltaChain> getNextChain(const Key &key) {
-      return std::make_shared<DeltaChain>(GET_DELTA_CHAIN_NOT_FOUND);
-    }
-  public:
-    DeltaChainIterator(std::shared_ptr<DeltaChain> chain) :
-      _index(0) {
-      _chains.push_back(chain);
-    }
-
-    DeltaChainLink next() {
-      std::shared_ptr<DeltaChain> chain = _chains.back();
-
-      if (_index >= chain->linkcount()) {
-        // If we're not at the end, and we have a callback to fetch more, do the
-        // fetch.
-        bool refreshed = false;
-        if (chain->linkcount() > 0) {
-          DeltaChainLink result = chain->getlink(_index - 1);
-
-          const uint8_t *deltabasenode = result.deltabasenode();
-          if (memcmp(deltabasenode, NULLID, BIN_NODE_SIZE) != 0) {
-            Key key(result.filename(), result.filenamesz(),
-                    (const char*)deltabasenode, BIN_NODE_SIZE);
-
-            std::shared_ptr<DeltaChain> newChain = this->getNextChain(key);
-            if (newChain->code() == GET_DELTA_CHAIN_OK) {
-              // Do not free the old chain, since the iterator consumer may
-              // still be holding references to it.
-              _chains.push_back(newChain);
-              chain = _chains.back();
-              _index = 0;
-              refreshed = true;
-            }
-          }
-        }
-
-        if (!refreshed) {
-          return DeltaChainLink(NULL);
-        }
-      }
-
-      DeltaChainLink result = chain->getlink(_index);
-      _index++;
-
-      return result;
-    }
-};
+#include "cstore/deltachain.h"
+#include "cstore/key.h"
 
 class DataStore {
   protected:
diff --git a/cstore/deltachain.h b/cstore/deltachain.h
new file mode 100644
--- /dev/null
+++ b/cstore/deltachain.h
@@ -0,0 +1,203 @@
+// Copyright (c) 2004-present, Facebook, Inc.
+// All Rights Reserved.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+
+// deltachain.h - c++ declaration of deltachain and related classes
+// no-check-code
+
+#ifndef FBHGEXT_DELTACHAIN_H
+#define FBHGEXT_DELTACHAIN_H
+
+extern "C" {
+#include "cdatapack/cdatapack.h"
+}
+
+#include <memory>
+#include <vector>
+
+#include "cstore/key.h"
+
+/*
+ * Wrapper around delta chain link, both C and Python
+ */
+class DeltaChainLink {
+  private:
+    const char *_filename, *_deltabasefilename;
+    const uint8_t *_node, *_deltabasenode, *_delta;
+    uint16_t _filenamesz;
+    uint64_t _deltasz;
+
+  public:
+    DeltaChainLink(delta_chain_link_t *link) {
+      if (link) {
+        _filename = link->filename;
+        _deltabasefilename = link->filename;
+        _node = link->node;
+        _deltabasenode = link->deltabase_node;
+        _delta = link->delta;
+        _filenamesz = link->filename_sz;
+        _deltasz = link->delta_sz;
+      } else {
+        _filename = NULL;
+        _deltabasefilename = NULL;
+        _node = NULL;
+        _deltabasenode = NULL;
+        _delta = NULL;
+        _filenamesz = 0;
+        _deltasz = 0;
+      }
+    }
+
+    DeltaChainLink(const char *filename,
+                                   const char *deltabasefilename,
+                                   const uint8_t *node,
+                                   const uint8_t *deltabasenode,
+                                   const uint8_t *delta,
+                                   uint16_t filenamesz,
+                                   uint64_t deltasz) :
+      _filename(filename),
+      _deltabasefilename(deltabasefilename),
+      _node(node),
+      _deltabasenode(deltabasenode),
+      _delta(delta),
+      _filenamesz(filenamesz),
+      _deltasz(deltasz) {}
+
+    ~DeltaChainLink() = default;
+
+    const char* filename() {
+      return _filename;
+    }
+
+    const char* deltabasefilename() {
+      return _deltabasefilename;
+    }
+
+    const uint8_t* node() {
+      return _node;
+    }
+
+    const uint8_t* deltabasenode() {
+      return _deltabasenode;
+    }
+
+    const uint8_t* delta() {
+      return _delta;
+    }
+
+    uint16_t filenamesz() {
+      return _filenamesz;
+    }
+
+    uint64_t deltasz() {
+      return _deltasz;
+    }
+
+    bool isdone() {
+      return (_filename == NULL);
+    }
+};
+
+/*
+ * Abstract delta chain class
+ */
+class DeltaChain {
+  protected:
+    DeltaChain() {}
+
+  public:
+    virtual ~DeltaChain() {}
+
+    virtual const DeltaChainLink getlink(const size_t) = 0;
+
+    virtual size_t linkcount() = 0;
+
+    virtual get_delta_chain_code_t status() = 0;
+};
+
+/*
+ * Wrapper around C delta chain
+ * CDeltaChain takes ownership of delta_chain_t
+ */
+class CDeltaChain : public DeltaChain {
+  private:
+    delta_chain_t _chain;
+
+  public:
+    //The constructor does a shallow copy of the delta chain and since the
+    //ownership is taken by this class it is responsible for memory management
+    CDeltaChain(delta_chain_t chain) : _chain(chain) {}
+
+    CDeltaChain(get_delta_chain_code_t error) :
+      _chain(COMPOUND_LITERAL(delta_chain_t) { GET_DELTA_CHAIN_NOT_FOUND }) {}
+
+    ~CDeltaChain() {
+      freedeltachain(_chain);
+    }
+
+    const DeltaChainLink getlink(const size_t idx) {
+      return DeltaChainLink(&(_chain.delta_chain_links[idx]));
+    }
+
+    size_t linkcount() {
+      return _chain.links_count;
+    }
+
+    get_delta_chain_code_t status() {
+      return _chain.code;
+    }
+};
+
+/*
+ * Wrapper around python delta chain
+ */
+class PyDeltaChain : public DeltaChain {
+  private:
+    std::shared_ptr< std::vector<DeltaChainLink> > _chain;
+
+  public:
+    PyDeltaChain(std::shared_ptr< std::vector<DeltaChainLink> > chain) :
+      _chain(chain) {}
+
+    ~PyDeltaChain() {}
+
+    const DeltaChainLink getlink(const size_t idx) {
+      return _chain->at(idx);
+    }
+
+    size_t linkcount() {
+      return _chain->size();
+    }
+
+    get_delta_chain_code_t status() {
+      if (_chain->size()) {
+        return GET_DELTA_CHAIN_OK;
+      } else {
+        return GET_DELTA_CHAIN_NOT_FOUND;
+      }
+    }
+
+};
+
+class DeltaChainIterator {
+  private:
+    size_t _index;
+  protected:
+    std::vector< std::shared_ptr<DeltaChain> > _chains;
+    DeltaChainIterator() :
+      _index(0) {}
+    virtual std::shared_ptr<DeltaChain> getNextChain(const Key &key) {
+      return std::make_shared<CDeltaChain>(GET_DELTA_CHAIN_NOT_FOUND);
+    }
+  public:
+    DeltaChainIterator(std::shared_ptr<DeltaChain> chain) :
+      _index(0) {
+      _chains.push_back(chain);
+    }
+
+    DeltaChainLink next();
+};
+
+#endif // FBHGEXT_DELTACHAIN_H
diff --git a/cstore/deltachain.cpp b/cstore/deltachain.cpp
new file mode 100644
--- /dev/null
+++ b/cstore/deltachain.cpp
@@ -0,0 +1,48 @@
+// Copyright (c) 2004-present, Facebook, Inc.
+// All Rights Reserved.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+
+// deltachain.h - c++ implementation of deltachain and related classes
+// no-check-code
+
+#include "cstore/deltachain.h"
+
+DeltaChainLink DeltaChainIterator::next() {
+  std::shared_ptr<DeltaChain> chain = _chains.back();
+
+  if (_index >= chain->linkcount()) {
+    // If we're not at the end, and we have a callback to fetch more, do the
+    // fetch.
+    bool refreshed = false;
+    if (chain->linkcount() > 0) {
+      DeltaChainLink result = chain->getlink(_index - 1);
+
+      const uint8_t *deltabasenode = result.deltabasenode();
+      if (memcmp(deltabasenode, NULLID, BIN_NODE_SIZE) != 0) {
+        Key key(result.filename(), result.filenamesz(),
+                (const char*)deltabasenode, BIN_NODE_SIZE);
+
+        std::shared_ptr<DeltaChain> newChain = this->getNextChain(key);
+        if (newChain->status() == GET_DELTA_CHAIN_OK) {
+          // Do not free the old chain, since the iterator consumer may
+          // still be holding references to it.
+          _chains.push_back(newChain);
+          chain = _chains.back();
+          _index = 0;
+          refreshed = true;
+        }
+      }
+    }
+
+    if (!refreshed) {
+      return DeltaChainLink(NULL);
+    }
+  }
+
+  DeltaChainLink result = chain->getlink(_index);
+  _index++;
+
+  return result;
+}
diff --git a/cstore/py-datapackstore.h b/cstore/py-datapackstore.h
--- a/cstore/py-datapackstore.h
+++ b/cstore/py-datapackstore.h
@@ -26,6 +26,8 @@
 #include "cstore/key.h"
 #include "cstore/py-structs.h"
 #include "cstore/pythonutil.h"
+#include "cstore/pythonkeyiterator.h"
+#include "cstore/pythondatastore.h"
 #include "cstore/uniondatapackstore.h"
 
 // --------- DatapackStore Implementation ---------
@@ -109,35 +111,6 @@
   }
 }
 
-class PythonKeyIterator : public KeyIterator {
-  private:
-    PythonObj _input;
-    Key _current;
-  public:
-    PythonKeyIterator(PythonObj input) :
-      _input(input) {}
-
-    Key *next() {
-      PyObject *item;
-      while ((item = PyIter_Next((PyObject*)_input)) != NULL) {
-        PythonObj itemObj = item;
-
-        char *name;
-        Py_ssize_t namelen;
-        char *node;
-        Py_ssize_t nodelen;
-        if (!PyArg_ParseTuple(item, "s#s#", &name, &namelen, &node, &nodelen)) {
-          throw pyexception();
-        }
-
-        _current = Key(name, namelen, node, nodelen);
-        return &_current;
-      }
-
-      return NULL;
-    }
-};
-
 static PyObject *datapackstore_getmissing(py_datapackstore *self, PyObject *keys) {
   try {
     PythonObj result = PyList_New(0);
@@ -233,6 +206,7 @@
 
   try {
     std::vector<DataStore*> stores;
+    std::vector<PythonObj> cSubStores;
     std::vector<PythonObj> pySubStores;
 
     PyObject *item;
@@ -241,26 +215,27 @@
       // Record the substore references, so:
       // A) We can decref them in case of an error.
       // B) They don't get GC'd while the uniondatapackstore holds on to them.
-      pySubStores.push_back(PythonObj(item));
+      int isinstance = PyObject_IsInstance(item, (PyObject*)&datapackstoreType);
 
-      int isinstance = PyObject_IsInstance(item, (PyObject*)&datapackstoreType);
-      if (isinstance == 0) {
-        PyErr_SetString(PyExc_RuntimeError, "cuniondatapackstore only accepts cdatapackstore");
-        return -1;
-      } else if (isinstance != 1) {
-        // Error
-        return -1;
+      if (isinstance == 1) {
+        cSubStores.push_back(PythonObj(item));
+        py_datapackstore *subStore = (py_datapackstore*)item;
+        stores.push_back(&subStore->datapackstore);
+      } else {
+        pySubStores.push_back(PythonObj(item));
+        py_pythondatastore *subStore = (py_pythondatastore*)item;
+        stores.push_back(&subStore->pythondatastore);
       }
-
-      py_datapackstore *pySubStore = (py_datapackstore*)item;
-      stores.push_back(&pySubStore->datapackstore);
     }
 
     // We have to manually call the member constructor, since the provided 'self'
     // is just zerod out memory.
     new(&self->uniondatapackstore) std::shared_ptr<UnionDatapackStore>(new UnionDatapackStore(stores));
-    new(&self->substores) std::vector<PythonObj>();
-    self->substores = pySubStores;
+    new(&self->cstores) std::vector<PythonObj>();
+    new(&self->pystores) std::vector<PythonObj>();
+
+    self->cstores = cSubStores;
+    self->pystores = pySubStores;
   } catch (const std::exception &ex) {
     PyErr_SetString(PyExc_RuntimeError, ex.what());
     return -1;
@@ -271,7 +246,8 @@
 
 static void uniondatapackstore_dealloc(py_uniondatapackstore *self) {
   self->uniondatapackstore.~shared_ptr<UnionDatapackStore>();
-  self->substores.~vector<PythonObj>();
+  self->cstores.~vector<PythonObj>();
+  self->pystores.~vector<PythonObj>();
   PyObject_Del(self);
 }
 
diff --git a/cstore/py-pythondatastore.h b/cstore/py-pythondatastore.h
new file mode 100644
--- /dev/null
+++ b/cstore/py-pythondatastore.h
@@ -0,0 +1,83 @@
+// python implementation of a common interface
+//
+// Copyright 2017 Facebook, Inc.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+//
+// no-check-code
+
+// The PY_SSIZE_T_CLEAN define must be defined before the Python.h include,
+// as per the documentation.
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <memory>
+#include <vector>
+
+#include "datastore.h"
+#include "key.h"
+#include "pythonutil.h"
+#include "pythonkeyiterator.h"
+
+static std::shared_ptr<DeltaChain> pythonstore_getdeltachain(void *_store,
+                                                             const Key &key) {
+  PythonObj store((PyObject*)_store);
+  // Build (name, node) tuple and call getdeltachain
+  // method of the underlying store
+  PythonObj pyKey = Py_BuildValue("(s#s#)", (key.name).c_str(),
+                                (key.name).size(), key.node, 20);
+  PythonObj list = store.callmethod("getdeltachain", pyKey);
+
+  // Extract the delta chain from the list of tuples
+  // and build a DeltaChain object from them
+  std::shared_ptr< std::vector<DeltaChainLink> > links =
+      std::make_shared< std::vector<DeltaChainLink> >();
+
+  PythonObj iter = PyObject_GetIter(list);
+  PyObject *tuple;
+  while ((tuple = PyIter_Next(iter)) != NULL) {
+    const char *filename, *deltabasefilename;
+    const uint8_t *node, *deltabasenode, *delta;
+    uint16_t filenamesz;
+    uint64_t deltasz;
+
+    int ok = PyArg_ParseTuple(tuple, "s#zszz#",
+                              &filename, &filenamesz, &node,
+                              &deltabasefilename, &deltabasenode,
+                              &delta, &deltasz);
+
+    // the item is a five tuple
+    if (ok) {
+      links->push_back(DeltaChainLink(filename, deltabasefilename, node,
+                                      deltabasenode, delta, filenamesz,
+                                      deltasz));
+    }
+  }
+
+  return std::make_shared<PyDeltaChain>(links);
+}
+
+static std::shared_ptr<KeyIterator> pythonstore_getmissing(void *_store, KeyIterator &missing) {
+  PythonObj store((PyObject*)_store);
+  PythonObj list = PyList_New(0);
+
+  Key *key;
+  while ((key = missing.next()) != NULL) {
+    PythonObj pyKey = Py_BuildValue("(s#s#)", key->name.c_str(),
+                                    key->name.size(), key->node, 20);
+    if (PyList_Append(list, (PyObject*)pyKey)) {
+      return NULL; //throw an error
+    }
+  }
+
+  PythonObj keys = store.callmethod("getmissing", list);
+  return std::make_shared<PythonKeyIterator>(keys);
+}
+
+static void pythonstore_markforrefresh(void *_store) {
+  PythonObj store((PyObject*)_store);
+  PythonObj args = Py_BuildValue("");
+  store.callmethod("markforrefresh", args);
+}
diff --git a/cstore/py-structs.h b/cstore/py-structs.h
--- a/cstore/py-structs.h
+++ b/cstore/py-structs.h
@@ -13,6 +13,7 @@
 #include <memory>
 
 #include "cstore/datapackstore.h"
+#include "cstore/pythondatastore.h"
 #include "cstore/pythonutil.h"
 #include "cstore/uniondatapackstore.h"
 
@@ -22,13 +23,20 @@
   DatapackStore datapackstore;
 };
 
+struct py_pythondatastore {
+  PyObject_HEAD;
+
+  PythonDataStore pythondatastore;
+};
+
 struct py_uniondatapackstore {
   PyObject_HEAD;
 
   std::shared_ptr<UnionDatapackStore> uniondatapackstore;
 
   // Keep a reference to the python objects so we can decref them later.
-  std::vector<PythonObj> substores;
+  std::vector<PythonObj> cstores;
+  std::vector<PythonObj> pystores;
 };
 
 #endif // FBHGEXT_CSTORE_PY_STRUCTS_H
diff --git a/cstore/pythondatastore.h b/cstore/pythondatastore.h
new file mode 100644
--- /dev/null
+++ b/cstore/pythondatastore.h
@@ -0,0 +1,37 @@
+// pythondatastore.h - c++ declarations for a python data store
+//
+// Copyright 2017 Facebook, Inc.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+//
+// no-check-code
+
+#ifndef FBHGEXT_PYTHONDATASTORE_H
+#define FBHGEXT_PYTHONDATASTORE_H
+
+#include <memory>
+
+#include "cstore/datastore.h"
+#include "cstore/key.h"
+
+class PythonDataStore : public DataStore {
+  private:
+    void* _store; // pointer to python object
+  public:
+    PythonDataStore(void* store);
+
+    ~PythonDataStore() = default;
+
+    DeltaChainIterator getDeltaChain(const Key &key);
+
+    std::shared_ptr<KeyIterator> getMissing(KeyIterator &missing);
+
+    std::shared_ptr<DeltaChain> getDeltaChainRaw(const Key &key);
+
+    bool contains(const Key &key);
+
+    void markForRefresh();
+};
+
+#endif //FBHGEXT_PYTHONDATASTORE_H
diff --git a/cstore/pythondatastore.cpp b/cstore/pythondatastore.cpp
new file mode 100644
--- /dev/null
+++ b/cstore/pythondatastore.cpp
@@ -0,0 +1,48 @@
+// pythondatastore.cpp - implementation of a python data store
+//
+// Copyright 2017 Facebook, Inc.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+//
+// no-check-code
+
+#include "py-pythondatastore.h"
+#include "pythondatastore.h"
+
+PythonDataStore::PythonDataStore(void* store) : _store(store) {}
+
+DeltaChainIterator PythonDataStore::getDeltaChain(const Key &key) {
+  std::shared_ptr<DeltaChain> chain = pythonstore_getdeltachain(_store, key);
+  return DeltaChainIterator(chain);
+}
+
+std::shared_ptr<DeltaChain> PythonDataStore::getDeltaChainRaw(const Key &key) {
+  return pythonstore_getdeltachain(_store, key);
+}
+
+std::shared_ptr<KeyIterator> PythonDataStore::getMissing(KeyIterator &missing) {
+  return pythonstore_getmissing(_store, missing);
+}
+
+void PythonDataStore::markForRefresh() {
+  pythonstore_markforrefresh(_store);
+}
+
+class Single : public KeyIterator {
+  public:
+    Key *_k;
+    Single(Key *k) : _k(k) {}
+    Key *next() {
+      Key *tmp = _k;
+      _k = NULL;
+      return tmp;
+    }
+};
+
+bool PythonDataStore::contains(const Key &key) {
+  Key copy = key;
+  Single iter(&copy);
+  std::shared_ptr<KeyIterator> it = pythonstore_getmissing(_store, iter);
+  return (!it->next());
+}
diff --git a/cstore/pythonkeyiterator.h b/cstore/pythonkeyiterator.h
new file mode 100644
--- /dev/null
+++ b/cstore/pythonkeyiterator.h
@@ -0,0 +1,44 @@
+// pythonkeyiterator.h - c++ implementation of python key iterator
+//
+// Copyright 2017 Facebook, Inc.
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+//
+// no-check-code
+
+#ifndef FBHGEXT_PYTHONKEYITERATOR_H
+#define FBHGEXT_PYTHONKEYITERATOR_H
+
+#include "cstore/pythonutil.h"
+
+class PythonKeyIterator : public KeyIterator {
+  private:
+    PythonObj _input;
+    Key _current;
+  public:
+    PythonKeyIterator(PythonObj input) :
+      _input(input) {}
+
+    Key *next() {
+        PyObject *item;
+        while ((item = PyIter_Next((PyObject*)_input)) != NULL) {
+          PythonObj itemObj = item;
+
+          char *name;
+          Py_ssize_t namelen;
+          char *node;
+          Py_ssize_t nodelen;
+          if (!PyArg_ParseTuple(item, "s#s#", &name, &namelen, &node, &nodelen)) {
+            throw pyexception();
+          }
+
+          _current = Key(name, namelen, node, nodelen);
+          return &_current;
+        }
+
+        return NULL;
+    }
+};
+
+#endif //FBHGEXT_PYTHONKEYITERATOR_H
diff --git a/cstore/uniondatapackstore.cpp b/cstore/uniondatapackstore.cpp
--- a/cstore/uniondatapackstore.cpp
+++ b/cstore/uniondatapackstore.cpp
@@ -93,7 +93,7 @@
     DataStore *substore = *it;
     std::shared_ptr<DeltaChain> chain = substore->getDeltaChainRaw(key);
 
-    if (chain->code() == GET_DELTA_CHAIN_OK) {
+    if (chain->status() == GET_DELTA_CHAIN_OK) {
       return chain;
     }
   }
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -239,8 +239,10 @@
             Extension('cstore',
                 sources=[
                     'cstore/datapackstore.cpp',
+                    'cstore/deltachain.cpp',
                     'cstore/py-cstore.cpp',
                     'cstore/pythonutil.cpp',
+                    'cstore/pythondatastore.cpp',
                     'cstore/uniondatapackstore.cpp',
                     'ctreemanifest/manifest.cpp',
                     'ctreemanifest/manifest_entry.cpp',
diff --git a/tests/test-check-code-hg.t b/tests/test-check-code-hg.t
--- a/tests/test-check-code-hg.t
+++ b/tests/test-check-code-hg.t
@@ -65,13 +65,19 @@
   Skipping cstore/datapackstore.cpp it has no-che?k-code (glob)
   Skipping cstore/datapackstore.h it has no-che?k-code (glob)
   Skipping cstore/datastore.h it has no-che?k-code (glob)
+  Skipping cstore/deltachain.cpp it has no-che?k-code (glob)
+  Skipping cstore/deltachain.h it has no-che?k-code (glob)
   Skipping cstore/key.h it has no-che?k-code (glob)
   Skipping cstore/match.h it has no-che?k-code (glob)
   Skipping cstore/py-cdatapack.h it has no-che?k-code (glob)
   Skipping cstore/py-cstore.cpp it has no-che?k-code (glob)
   Skipping cstore/py-datapackstore.h it has no-che?k-code (glob)
+  Skipping cstore/py-pythondatastore.h it has no-che?k-code (glob)
   Skipping cstore/py-structs.h it has no-che?k-code (glob)
   Skipping cstore/py-treemanifest.h it has no-che?k-code (glob)
+  Skipping cstore/pythondatastore.cpp it has no-che?k-code (glob)
+  Skipping cstore/pythondatastore.h it has no-che?k-code (glob)
+  Skipping cstore/pythonkeyiterator.h it has no-che?k-code (glob)
   Skipping cstore/pythonutil.cpp it has no-che?k-code (glob)
   Skipping cstore/pythonutil.h it has no-che?k-code (glob)
   Skipping cstore/store.h it has no-che?k-code (glob)