Iyer/issue138

dsi/backends/filesystem.py

@@ -14,31 +14,51 @@ def git_commit_sha(self):
     @abstractmethod
     def put_artifacts(self, artifacts, kwargs) -> None:
         pass
+
+    @abstractmethod
+    def ingest_artifacts(self, artifacts, kwargs) -> None:
+        pass
 
     @abstractmethod
     def get_artifacts(self, query, kwargs):
         pass
 
     @abstractmethod
-    def write_artifacts(self, artifacts, kwargs) -> None:
+    def query_artifacts(self, query, kwargs):
         pass
 
     @abstractmethod
-    def process_artifacts(self, query, kwargs):
+    def inspect_artifacts(self, kwargs):
         pass
 
     @abstractmethod
-    def inspect_artifacts(self, kwargs):
+    def notebook(self, kwargs):
         pass
-    
+
     @abstractmethod
     def read_to_artifacts(self, kwargs):
         pass
 
+    @abstractmethod
+    def process_artifacts(self, kwargs):
+        pass
+
     @abstractmethod
     def find(self, query_object, kwargs):
         pass
-
+
+    @abstractmethod
+    def find_table(self, query_object, kwargs):
+        pass
+
+    @abstractmethod
+    def find_column(self, query_object, kwargs):
+        pass
+
+    @abstractmethod
+    def find_cell(self, query_object, kwargs):
+        pass
+
     @abstractmethod
     def close(self):
         pass
@@ -67,23 +87,38 @@ def __init__(self, filename) -> None:
     def put_artifacts(self, artifacts, kwargs) -> None:
         pass
 
-    def get_artifacts(self, query, kwargs):
+    def ingest_artifacts(self, artifacts, kwargs) -> None:
         pass
 
-    def write_artifacts(self, artifacts, kwargs) -> None:
+    def get_artifacts(self, query, kwargs):
         pass
 
-    def process_artifacts(self, query, kwargs):
+    def query_artifacts(self, query, kwargs):
         pass
 
     def inspect_artifacts(self, kwargs):
         pass
-
+
+    def notebook(self, kwargs):
+        pass
+
     def read_to_artifacts(self, kwargs):
         pass
 
+    def process_artifacts(self, kwargs):
+        pass
+
     def find(self, query_object, kwargs):
         pass
 
+    def find_table(self, query_object, kwargs):
+        pass
+
+    def find_column(self, query_object, kwargs):
+        pass
+
+    def find_cell(self, query_object, kwargs):
+        pass
+
     def close(self):
         pass

dsi/backends/tests/test_sqlite.py

@@ -33,8 +33,8 @@ def test_artifact_put():
     dbpath = 'test_artifact.db'
     if os.path.exists(dbpath):
         os.remove(dbpath)
-    store = Sqlite(dbpath, run_table=False)
-    store.write_artifacts(valid_middleware_datastructure)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
     store.close()
     # No error implies success
     assert True
@@ -53,9 +53,9 @@ def test_artifact_get():
     dbpath = 'test_artifact.db'
     if os.path.exists(dbpath):
         os.remove(dbpath)
-    store = Sqlite(dbpath, run_table=False)
-    store.write_artifacts(valid_middleware_datastructure)
-    query_data = store.process_artifacts(query = "SELECT * FROM wildfire;")
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+    query_data = store.get_artifacts(query = "SELECT * FROM wildfire;")
     store.close()
     correct_output = [(1, 3), (2, 2), (3, 1)]
     assert query_data == correct_output
@@ -65,8 +65,8 @@ def test_artifact_inspect():
     dbpath = 'test_artifact.db'
     if os.path.exists(dbpath):
         os.remove(dbpath)
-    store = Sqlite(dbpath, run_table=False)
-    store.write_artifacts(valid_middleware_datastructure)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
     store.inspect_artifacts()
     store.close()
     assert True
@@ -76,41 +76,110 @@ def test_artifact_read():
     dbpath = 'test_artifact.db'
     if os.path.exists(dbpath):
         os.remove(dbpath)
-    store = Sqlite(dbpath, run_table=False)
-    store.write_artifacts(valid_middleware_datastructure)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
     artifact = store.read_to_artifact()
     store.close()
     assert artifact == valid_middleware_datastructure
 
 def test_find():
-    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':[3,2,1]})})
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
+    dbpath = 'test_artifact.db'
+    if os.path.exists(dbpath):
+        os.remove(dbpath)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    find_data = store.find("f")
+    assert len(find_data) == 3
+    assert find_data[0].t_name == "wildfire"
+    assert find_data[0].c_name == ['foo', 'bar']
+    assert find_data[0].type == 'table'
+    assert find_data[1].t_name == "wildfire"
+    assert find_data[1].c_name == ['foo']
+    assert find_data[1].value == [1,2,3]
+    assert find_data[1].type == 'column'
+    assert find_data[0].row_num == find_data[1].row_num
+    assert find_data[2].t_name == "wildfire"
+    assert find_data[2].c_name == ['bar']
+    assert find_data[2].value == "f"
+    assert find_data[2].type == 'cell'
+    assert find_data[2].row_num == 1
+
+    store.close()
+
+def test_find_table():
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
     dbpath = 'test_artifact.db'
     if os.path.exists(dbpath):
         os.remove(dbpath)
-    store = Sqlite(dbpath, run_table=False)
-    store.write_artifacts(valid_middleware_datastructure)
-    table_data = store.find("wildfire")
-    assert len(table_data) == 1
-    assert len(table_data[0]) == 2
-    assert len(table_data[0][1]) == 3
-
-    col_list = store.find("wildfire", colFlag=True)
-    assert len(col_list) == 1
-    assert len(col_list[0]) == 2
-    assert len(col_list[0][1]) == 2
-
-    col_data = store.find("foo")
-    assert len(col_data) == 1
-    assert len(col_data[0]) == 2
-    assert len(col_data[0][1]) == 3
-
-    col_data = store.find("foo", data_range=True)
-    assert len(col_data) == 1
-    assert len(col_data[0]) == 3
-    assert col_data[0][1] == "data range = (1, 3)"
-    assert len(col_data[0][2]) == 3
-
-    value_data = store.find(3)
-    assert len(value_data) == 2
-    assert len(value_data[0]) == 3
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    table_data = store.find_table("f")
+    assert table_data[0].t_name == "wildfire"
+    assert table_data[0].c_name == ['foo', 'bar']
+    assert table_data[0].type == 'table'
+    store.close()
+
+def test_find_column():
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
+    dbpath = 'test_artifact.db'
+    if os.path.exists(dbpath):
+        os.remove(dbpath)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    col_data = store.find_column("f")
+    assert col_data[0].t_name == "wildfire"
+    assert col_data[0].c_name == ['foo']
+    assert col_data[0].value == [1,2,3]
+    assert col_data[0].type == 'column'
+    store.close()
+
+def test_find_range():
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
+    dbpath = 'test_artifact.db'
+    if os.path.exists(dbpath):
+        os.remove(dbpath)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    range_data = store.find_column("f", range=True)
+    assert range_data[0].t_name == "wildfire"
+    assert range_data[0].c_name == ['foo']
+    assert range_data[0].value == [1,3]
+    assert range_data[0].type == 'range'
+    store.close()
+
+def test_find_cell():
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
+    dbpath = 'test_artifact.db'
+    if os.path.exists(dbpath):
+        os.remove(dbpath)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    cell_data = store.find_cell("f")
+    assert cell_data[0].t_name == "wildfire"
+    assert cell_data[0].c_name == ['bar']
+    assert cell_data[0].value == "f"
+    assert cell_data[0].row_num == 1
+    assert cell_data[0].type == 'cell'
+    store.close()
+
+def test_find_row():
+    valid_middleware_datastructure = OrderedDict({"wildfire": OrderedDict({'foo':[1,2,3],'bar':["f",2,1]})})
+    dbpath = 'test_artifact.db'
+    if os.path.exists(dbpath):
+        os.remove(dbpath)
+    store = Sqlite(dbpath)
+    store.put_artifacts(valid_middleware_datastructure)
+
+    row_data = store.find_cell("f", row = True)
+    assert row_data[0].t_name == "wildfire"
+    assert row_data[0].c_name == ['foo', 'bar']
+    assert row_data[0].value == [1,"f"]
+    assert row_data[0].row_num == 1
+    assert row_data[0].type == 'row'
     store.close()