coffy 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

coffy/graph/graph_tests.py

@@ -0,0 +1,137 @@
+import json
+import unittest
+import tempfile
+import os
+from graphdb_nx import GraphDB
+
+
+class TestGraphDB(unittest.TestCase):
+
+    def setUp(self):
+        self.temp_path = tempfile.NamedTemporaryFile(delete=False, suffix=".json").name
+        self.db = GraphDB(path=self.temp_path)
+        self.db.add_node("A", labels="Person", name="Alice", age=30)
+        self.db.add_node("B", labels="Person", name="Bob", age=25)
+        self.db.add_node("C", labels="Person", name="Carol", age=40)
+        self.db.add_relationship("A", "B", rel_type="KNOWS", since=2010)
+        self.db.add_relationship("B", "C", rel_type="KNOWS", since=2015)
+
+    def tearDown(self):
+        os.remove(self.temp_path)
+
+    def test_add_and_get_node(self):
+        self.db.add_node("D", labels="Person", name="Dan")
+        node = self.db.get_node("D")
+        self.assertEqual(node["name"], "Dan")
+
+    def test_remove_node(self):
+        self.db.remove_node("C")
+        self.assertFalse(self.db.has_node("C"))
+
+    def test_add_and_get_relationship(self):
+        rel = self.db.get_relationship("A", "B")
+        self.assertEqual(rel["_type"], "KNOWS")
+
+    def test_update_node(self):
+        self.db.update_node("A", age=35, city="Wonderland")
+        node = self.db.get_node("A")
+        self.assertEqual(node["age"], 35)
+        self.assertEqual(node["city"], "Wonderland")
+
+    def test_update_relationship(self):
+        self.db.update_relationship("A", "B", since=2020, weight=0.8)
+        rel = self.db.get_relationship("A", "B")
+        self.assertEqual(rel["since"], 2020)
+        self.assertEqual(rel["weight"], 0.8)
+
+    def test_set_node_update(self):
+        self.db.set_node("A", name="Alicia", mood="happy")
+        node = self.db.get_node("A")
+        self.assertEqual(node["name"], "Alicia")
+        self.assertEqual(node["mood"], "happy")
+
+    def test_set_node_add(self):
+        self.db.set_node("Z", labels="Robot", name="Zeta", age=5)
+        self.assertTrue(self.db.has_node("Z"))
+        node = self.db.get_node("Z")
+        self.assertEqual(node["name"], "Zeta")
+        self.assertEqual(node["age"], 5)
+        self.assertIn("Robot", node["_labels"])
+
+    def test_remove_relationship(self):
+        self.db.remove_relationship("A", "B")
+        self.assertFalse(self.db.has_relationship("A", "B"))
+
+    def test_find_nodes_basic(self):
+        results = self.db.find_nodes(name="Alice")
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["name"], "Alice")
+
+    def test_find_nodes_logic_or(self):
+        results = self.db.find_nodes(_logic="or", name="Alice", age={"gt": 35})
+        names = {r["name"] for r in results}
+        self.assertIn("Alice", names)
+        self.assertIn("Carol", names)
+
+    def test_find_nodes_logic_not(self):
+        results = self.db.find_nodes(_logic="not", age={"lt": 35})
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["name"], "Carol")
+
+    def test_find_by_label(self):
+        results = self.db.find_by_label("Person")
+        self.assertEqual(len(results), 3)
+
+    def test_find_relationships_type_and_filter(self):
+        results = self.db.find_relationships(rel_type="KNOWS", since={"gte": 2011})
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["target"], "C")
+
+    def test_project_node_fields(self):
+        result = self.db.project_node("A", fields=["name"])
+        self.assertEqual(result, {"name": "Alice"})
+
+    def test_project_relationship_fields(self):
+        result = self.db.project_relationship("A", "B", fields=["since"])
+        self.assertEqual(result, {"since": 2010})
+
+    def test_match_node_path(self):
+        pattern = [{"rel_type": "KNOWS", "node": {"name": "Bob"}}]
+        paths = self.db.match_node_path(start={"name": "Alice"}, pattern=pattern)
+        self.assertEqual(len(paths), 1)
+        self.assertEqual(paths[0][0]["name"], "Alice")
+        self.assertEqual(paths[0][1]["name"], "Bob")
+
+    def test_match_full_path(self):
+        pattern = [{"rel_type": "KNOWS", "node": {"name": "Bob"}}, {"rel_type": "KNOWS", "node": {"name": "Carol"}}]
+        results = self.db.match_full_path(start={"name": "Alice"}, pattern=pattern)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["nodes"][2]["name"], "Carol")
+        self.assertEqual(results[0]["relationships"][0]["type"], "KNOWS")
+
+    def test_match_path_structured(self):
+        pattern = [{"rel_type": "KNOWS", "node": {"name": "Bob"}}]
+        result = self.db.match_path_structured(start={"name": "Alice"}, pattern=pattern)
+        self.assertEqual(len(result), 1)
+        path = result[0]["path"]
+        self.assertEqual(path[0]["node"]["name"], "Alice")
+        self.assertEqual(path[1]["relationship"]["type"], "KNOWS")
+        self.assertEqual(path[2]["node"]["name"], "Bob")
+
+    def test_save_and_load(self):
+        self.db.save()
+        new_db = GraphDB(path=self.temp_path)
+        self.assertTrue(new_db.has_node("A"))
+        self.assertTrue(new_db.has_relationship("A", "B"))
+
+    def test_save_query_result(self):
+        result = self.db.find_nodes(name="Alice")
+        temp_result_path = self.temp_path.replace(".json", "_result.json")
+        self.db.save_query_result(result, path=temp_result_path)
+        with open(temp_result_path) as f:
+            loaded = json.load(f)
+        self.assertEqual(loaded[0]["name"], "Alice")
+        os.remove(temp_result_path)
+
+
+unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromTestCase(TestGraphDB))

coffy/graph/graphdb_nx.py

@@ -1,43 +1,85 @@
+# coffy/graph/graphdb_nx.py
+# author: nsarathy
+
 import networkx as nx
 import json
 import os
 
 class GraphDB:
+
     def __init__(self, directed=False, path=None):
         self.g = nx.DiGraph() if directed else nx.Graph()
         self.directed = directed
-        self.path = path
-        if path and os.path.exists(path):
-            self.load(path)
+        self.in_memory = path == ":memory:"
+
+        if path:
+            if not path.endswith(".json"):
+                raise ValueError("Path must be to a .json file")
+            self.path = path
+        else:
+            self.in_memory = True
+        if not self.in_memory and os.path.exists(self.path):
+            self.load(self.path)
+        elif not self.in_memory:
+            os.makedirs(os.path.dirname(self.path), exist_ok=True)
+            self.save(self.path)
+
 
     # Node operations
-    def add_node(self, node_id, **attrs):
+    def add_node(self, node_id, labels=None, **attrs):
+        if labels is not None:
+            attrs["_labels"] = labels if isinstance(labels, list) else [labels]
         self.g.add_node(node_id, **attrs)
+        self._persist()
 
     def add_nodes(self, nodes):
         for node in nodes:
-            self.add_node(node["id"], **{k: v for k, v in node.items() if k != "id"})
+            node_id = node["id"]
+            labels = node.get("labels") or node.get("_labels")  # Accept either form
+            attrs = {k: v for k, v in node.items() if k not in ["id", "labels", "_labels"]}
+            self.add_node(node_id, labels=labels, **attrs)
 
     def get_node(self, node_id):
         return self.g.nodes[node_id]
 
+    def _get_neighbors(self, node_id, direction):
+        if self.directed:
+            if direction == "out":
+                return self.g.successors(node_id)
+            elif direction == "in":
+                return self.g.predecessors(node_id)
+            elif direction == "any":
+                return set(self.g.successors(node_id)).union(self.g.predecessors(node_id))
+            else:
+                raise ValueError("Direction must be 'in', 'out', or 'any'")
+        else:
+            return self.g.neighbors(node_id)
+
     def remove_node(self, node_id):
         self.g.remove_node(node_id)
+        self._persist()
 
     # Relationship (edge) operations
-    def add_relationship(self, source, target, **attrs):
+    def add_relationship(self, source, target, rel_type=None, **attrs):
+        if rel_type:
+            attrs["_type"] = rel_type
         self.g.add_edge(source, target, **attrs)
+        self._persist()
 
     def add_relationships(self, relationships):
         for rel in relationships:
-            self.add_relationship(rel["source"], rel["target"],
-                                  **{k: v for k, v in rel.items() if k not in ["source", "target"]})
+            source = rel["source"]
+            target = rel["target"]
+            rel_type = rel.get("type") or rel.get("_type")
+            attrs = {k: v for k, v in rel.items() if k not in ["source", "target", "type", "_type"]}
+            self.add_relationship(source, target, rel_type=rel_type, **attrs)
 
     def get_relationship(self, source, target):
         return self.g.get_edge_data(source, target)
 
     def remove_relationship(self, source, target):
         self.g.remove_edge(source, target)
+        self._persist()
 
     # Basic queries
     def neighbors(self, node_id):
@@ -51,24 +93,74 @@ class GraphDB:
 
     def has_relationship(self, u, v):
         return self.g.has_edge(u, v)
+    
+    def update_node(self, node_id, **attrs):
+        if not self.has_node(node_id):
+            raise KeyError(f"Node '{node_id}' does not exist.")
+        self.g.nodes[node_id].update(attrs)
+        self._persist()
+
+    def update_relationship(self, source, target, **attrs):
+        if not self.has_relationship(source, target):
+            raise KeyError(f"Relationship '{source}->{target}' does not exist.")
+        self.g.edges[source, target].update(attrs)
+        self._persist()
+
+    def set_node(self, node_id, labels=None, **attrs):
+        if self.has_node(node_id):
+            self.update_node(node_id, **attrs)
+        else:
+            self.add_node(node_id, labels=labels, **attrs)
+        self._persist()
 
     # Advanced node search
-    def find_nodes(self, **conditions):
+    def project_node(self, node_id, fields=None):
+        if not self.has_node(node_id):
+            return None
+        node = self.get_node(node_id).copy()
+        node["id"] = node_id
+        if fields is None:
+            return node
+        return {k: node[k] for k in fields if k in node}
+
+    def project_relationship(self, source, target, fields=None):
+        if not self.has_relationship(source, target):
+            return None
+        rel = self.get_relationship(source, target).copy()
+        rel.update({"source": source, "target": target, "type": rel.get("_type")})
+        if fields is None:
+            return rel
+        return {k: rel[k] for k in fields if k in rel}
+
+    def find_nodes(self, label=None, fields=None, **conditions):
         return [
-            {"id": n, **a} for n, a in self.g.nodes(data=True)
-            if self._match_conditions(a, conditions)
+            self.project_node(n, fields) for n, a in self.g.nodes(data=True)
+            if (label is None or label in a.get("_labels", [])) and self._match_conditions(a, conditions)
         ]
 
-    def find_relationships(self, **conditions):
+    def find_by_label(self, label, fields=None):
         return [
-            {"source": u, "target": v, **a} for u, v, a in self.g.edges(data=True)
-            if self._match_conditions(a, conditions)
+            self.project_node(n, fields) for n, a in self.g.nodes(data=True)
+            if label in a.get("_labels", [])
+        ]
+
+    def find_relationships(self, rel_type=None, fields=None, **conditions):
+        return [
+            self.project_relationship(u, v, fields) for u, v, a in self.g.edges(data=True)
+            if (rel_type is None or a.get("_type") == rel_type) and self._match_conditions(a, conditions)
+        ]
+
+    def find_by_relationship_type(self, rel_type, fields=None):
+        return [
+            self.project_relationship(u, v, fields) for u, v, a in self.g.edges(data=True)
+            if a.get("_type") == rel_type
         ]
 
     def _match_conditions(self, attrs, conditions):
         if not conditions:
             return True
-        logic = conditions.pop("_logic", "and")
+        logic = conditions.get("_logic", "and")
+        conditions = {k: v for k, v in conditions.items() if k != "_logic"}
         results = []
 
         for key, expected in conditions.items():
@@ -90,13 +182,160 @@ class GraphDB:
         elif logic == "not":
             return not all(results)
         return all(results)
+    
+    def match_node_path(self, start, pattern, return_nodes=True, node_fields=None, direction="out"):
+        start_nodes = self.find_nodes(**start)
+        node_paths = []
+
+        for s in start_nodes:
+            self._match_node_path(
+                current_id=s["id"],
+                pattern=pattern,
+                node_path=[s["id"]],
+                node_paths=node_paths,
+                direction=direction
+            )
+
+        unique_paths = list({tuple(p) for p in node_paths})
+
+        if return_nodes:
+            return [
+                [self.project_node(n, node_fields) for n in path]
+                for path in unique_paths
+            ]
+        return unique_paths
+
+
+    def _match_node_path(self, current_id, pattern, node_path, node_paths, direction):
+        if not pattern:
+            node_paths.append(node_path)
+            return
+
+        step = pattern[0]
+        rel_type = step.get("rel_type")
+        next_node_cond = step.get("node", {})
+
+        for neighbor in self._get_neighbors(current_id, direction):
+            rel = self.get_relationship(current_id, neighbor)
+            if rel_type and rel.get("_type") != rel_type:
+                continue
+            node_attrs = self.get_node(neighbor)
+            if not self._match_conditions(node_attrs, next_node_cond):
+                continue
+            if neighbor in node_path:  # avoid cycles
+                continue
+            self._match_node_path(neighbor, pattern[1:], node_path + [neighbor], node_paths, direction)
+    
+    def match_full_path(self, start, pattern, node_fields=None, rel_fields=None, direction="out"):
+        start_nodes = self.find_nodes(**start)
+        matched_paths = []
+
+        for s in start_nodes:
+            self._match_full_path(
+                current_id=s["id"],
+                pattern=pattern,
+                relationship_path=[],
+                node_path=[s["id"]],
+                matched_paths=matched_paths,
+                direction=direction
+            )
+
+        return [
+            {
+                "nodes": [self.project_node(n, node_fields) for n in nodes],
+                "relationships": [self.project_relationship(u, v, rel_fields) for u, v in path]
+            }
+            for path, nodes in matched_paths
+        ]
+
+    def _match_full_path(self, current_id, pattern, relationship_path, node_path, matched_paths, direction):
+        if not pattern:
+            matched_paths.append((relationship_path, node_path))
+            return
+
+        step = pattern[0]
+        rel_type = step.get("rel_type")
+        next_node_cond = step.get("node", {})
+
+        for neighbor in self._get_neighbors(current_id, direction):
+            if neighbor in node_path:
+                continue
+            rel = self.get_relationship(current_id, neighbor)
+            if rel_type and rel.get("_type") != rel_type:
+                continue
+            if not self._match_conditions(self.get_node(neighbor), next_node_cond):
+                continue
+
+            self._match_full_path(
+                neighbor,
+                pattern[1:],
+                relationship_path + [(current_id, neighbor)],
+                node_path + [neighbor],
+                matched_paths,
+                direction
+            )
+            
+    def match_path_structured(self, start, pattern, node_fields=None, rel_fields=None, direction="out"):
+        start_nodes = self.find_nodes(**start)
+        structured_paths = []
+
+        for s in start_nodes:
+            self._match_structured_path(
+                current_id=s["id"],
+                pattern=pattern,
+                path=[{"node": self.project_node(s["id"], node_fields)}],
+                structured_paths=structured_paths,
+                direction=direction
+            )
+
+        return structured_paths
+    
+    def _match_structured_path(self, current_id, pattern, path, structured_paths, direction):
+        if not pattern:
+            structured_paths.append({"path": path})
+            return
+
+        step = pattern[0]
+        rel_type = step.get("rel_type")
+        next_node_cond = step.get("node", {})
+
+        for neighbor in self._get_neighbors(current_id, direction):
+            if any(e.get("node", {}).get("id") == neighbor for e in path):
+                continue  # Avoid cycles
+
+            rel = self.get_relationship(current_id, neighbor)
+            if rel_type and rel.get("_type") != rel_type:
+                continue
+            if not self._match_conditions(self.get_node(neighbor), next_node_cond):
+                continue
+
+            extended_path = path + [
+                {"relationship": self.project_relationship(current_id, neighbor)},
+                {"node": self.project_node(neighbor)}
+            ]
+
+            self._match_structured_path(
+                neighbor,
+                pattern[1:],
+                extended_path,
+                structured_paths,
+                direction
+            )
 
     # Export
     def nodes(self):
-        return [{"id": n, **a} for n, a in self.g.nodes(data=True)]
+        return [{"id": n, "labels": a.get("_labels", []), **{k: v for k, v in a.items() if k != "_labels"}} for n, a in self.g.nodes(data=True)]
 
     def relationships(self):
-        return [{"source": u, "target": v, **a} for u, v, a in self.g.edges(data=True)]
+        return [
+            {
+                "source": u,
+                "target": v,
+                "type": a.get("_type"),
+                **{k: v for k, v in a.items() if k != "_type"}
+            }
+            for u, v, a in self.g.edges(data=True)
+        ]
 
     def to_dict(self):
         return {
@@ -115,11 +354,26 @@ class GraphDB:
         path = path or self.path
         if not path:
             raise ValueError("No path specified to load the graph.")
+        if os.path.getsize(path) == 0:
+            return
         with open(path, "r", encoding="utf-8") as f:
             data = json.load(f)
         self.g.clear()
         for node in data.get("nodes", []):
             self.add_node(node["id"], **{k: v for k, v in node.items() if k != "id"})
         for rel in data.get("relationships", []):
-            self.add_relationship(rel["source"], rel["target"],
-                                  **{k: v for k, v in rel.items() if k not in ["source", "target"]})
+            self.add_relationship(
+                rel["source"], rel["target"],
+                rel_type=rel.get("type") or rel.get("_type"),
+                **{k: v for k, v in rel.items() if k not in ["source", "target", "type", "_type"]}
+            )
+    
+    def save_query_result(self, result, path=None):
+        if path is None:
+            raise ValueError("No path specified to save the query result.")
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(result, f, indent=4)
+            
+    def _persist(self):
+        if not self.in_memory:
+            self.save(self.path)

coffy/nosql/engine.py

@@ -13,47 +13,57 @@ class QueryBuilder:
         self.all_collections = all_collections or {}
         self._lookup_done = False
         self._lookup_results = None
+        
+    @staticmethod
+    def _get_nested(doc, dotted_key):
+        keys = dotted_key.split('.')
+        for k in keys:
+            if not isinstance(doc, dict) or k not in doc:
+                return None
+            doc = doc[k]
+        return doc
 
     def where(self, field):
         self.current_field = field
         return self
 
     # Comparison
-    def eq(self, value): return self._add_filter(lambda d: d.get(self.current_field) == value)
-    def ne(self, value): return self._add_filter(lambda d: d.get(self.current_field) != value)
+    def eq(self, value): return self._add_filter(lambda d: QueryBuilder._get_nested(d, self.current_field) == value)
+    def ne(self, value): return self._add_filter(lambda d: QueryBuilder._get_nested(d, self.current_field) != value)
     def gt(self, value):
         return self._add_filter(
-            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) > value
+            lambda d: isinstance(QueryBuilder._get_nested(d, self.current_field), (int, float)) and QueryBuilder._get_nested(d, self.current_field) > value
         )
 
     def gte(self, value):
         return self._add_filter(
-            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) >= value
+            lambda d: isinstance(QueryBuilder._get_nested(d, self.current_field), (int, float)) and QueryBuilder._get_nested(d, self.current_field) >= value
         )
 
     def lt(self, value):
         return self._add_filter(
-            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) < value
+            lambda d: isinstance(QueryBuilder._get_nested(d, self.current_field), (int, float)) and QueryBuilder._get_nested(d, self.current_field) < value
         )
 
     def lte(self, value):
         return self._add_filter(
-            lambda d: isinstance(d.get(self.current_field), (int, float)) and d.get(self.current_field) <= value
+            lambda d: isinstance(QueryBuilder._get_nested(d, self.current_field), (int, float)) and QueryBuilder._get_nested(d, self.current_field) <= value
         )
 
     def in_(self, values):
         return self._add_filter(
-            lambda d: d.get(self.current_field) in values
+            lambda d: QueryBuilder._get_nested(d, self.current_field) in values
         )
 
     def nin(self, values):
         return self._add_filter(
-            lambda d: d.get(self.current_field) not in values
+            lambda d: QueryBuilder._get_nested(d, self.current_field) not in values
         )
 
-    def matches(self, regex): return self._add_filter(lambda d: re.search(regex, str(d.get(self.current_field))))
+    def matches(self, regex): return self._add_filter(lambda d: re.search(regex, str(QueryBuilder._get_nested(d, self.current_field))))
     
-    def exists(self): return self._add_filter(lambda d: self.current_field in d)
+    def exists(self):
+        return self._add_filter(lambda d: QueryBuilder._get_nested(d, self.current_field) is not None)
 
     # Logic grouping
     def _and(self, *fns):
@@ -87,12 +97,24 @@ class QueryBuilder:
         return self
 
     # Core execution
-    def run(self):
+    def run(self, fields=None):
         results = [doc for doc in self.documents if all(f(doc) for f in self.filters)]
         if self._lookup_done:
             results = self._lookup_results
+
+        if fields is not None:
+            projected = []
+            for doc in results:
+                proj = {}
+                for f in fields:
+                    value = QueryBuilder._get_nested(doc, f)
+                    proj[f] = value
+                projected.append(proj)
+            return DocList(projected)
+
         return DocList(results)
 
+
     def update(self, changes):
         count = 0
         for doc in self.documents:
@@ -165,18 +187,17 @@ class QueryBuilder:
 _collection_registry = {}
 
 class CollectionManager:
-    DEFAULT_DIR = os.path.join(os.getcwd(), "nosql_data")
 
     def __init__(self, name: str, path: str = None):
         self.name = name
         self.in_memory = False
 
         if path:
+            if not path.endswith(".json"):
+                raise ValueError("Path must be to a .json file")
             self.path = path
         else:
-            os.makedirs(self.DEFAULT_DIR, exist_ok=True)
-            self.path = os.path.join(self.DEFAULT_DIR, f"{name}.json")
-            self.in_memory = True if name == ":memory:" else False
+            self.in_memory = True
 
         self.documents = []
         self._load()
@@ -190,6 +211,7 @@ class CollectionManager:
                 with open(self.path, 'r', encoding='utf-8') as f:
                     self.documents = json.load(f)
             except FileNotFoundError:
+                os.makedirs(os.path.dirname(self.path), exist_ok=True)
                 self.documents = []
 
     def _save(self):

coffy/nosql/nosql_tests.py

@@ -0,0 +1,104 @@
+# coffy/nosql/nosql_tests.py
+# author: nsarathy
+
+import unittest
+from engine import CollectionManager
+
+class TestCollectionManager(unittest.TestCase):
+
+    def setUp(self):
+        self.col = CollectionManager(name="test_collection")
+        self.col.clear()
+        self.col.add_many([
+            {"name": "Alice", "age": 30, "tags": ["x", "y"]},
+            {"name": "Bob", "age": 25, "tags": ["y", "z"]},
+            {"name": "Carol", "age": 40, "nested": {"score": 100}},
+        ])
+
+    def test_add_and_all_docs(self):
+        result = self.col.all_docs()
+        self.assertEqual(len(result), 3)
+
+    def test_where_eq(self):
+        q = self.col.where("name").eq("Alice")
+        self.assertEqual(q.count(), 1)
+        self.assertEqual(q.first()["age"], 30)
+
+    def test_where_gt_and_lt(self):
+        gt_q = self.col.where("age").gt(26)
+        lt_q = self.col.where("age").lt(40)
+        self.assertEqual(gt_q.count(), 2)
+        self.assertEqual(lt_q.count(), 2)
+
+    def test_exists(self):
+        q = self.col.where("nested").exists()
+        self.assertEqual(q.count(), 1)
+        self.assertEqual(q.first()["name"], "Carol")
+
+    def test_in_and_nin(self):
+        q1 = self.col.where("name").in_(["Alice", "Bob"])
+        q2 = self.col.where("name").nin(["Carol"])
+        self.assertEqual(q1.count(), 2)
+        self.assertEqual(q2.count(), 2)
+
+    def test_matches(self):
+        q = self.col.where("name").matches("^A")
+        self.assertEqual(q.count(), 1)
+        self.assertEqual(q.first()["name"], "Alice")
+
+    def test_nested_field_access(self):
+        q = self.col.where("nested.score").eq(100)
+        self.assertEqual(q.count(), 1)
+        self.assertEqual(q.first()["name"], "Carol")
+
+    def test_logic_and_or_not(self):
+        q = self.col.match_all(
+            lambda q: q.where("age").gte(25),
+            lambda q: q.where("age").lt(40)
+        )
+        self.assertEqual(q.count(), 2)
+
+        q = self.col.match_any(
+            lambda q: q.where("name").eq("Alice"),
+            lambda q: q.where("name").eq("Bob")
+        )
+        self.assertEqual(q.count(), 2)
+
+        q = self.col.not_any(
+            lambda q: q.where("name").eq("Bob"),
+            lambda q: q.where("age").eq(40)
+        )
+        self.assertEqual(q.count(), 1)
+        self.assertEqual(q.first()["name"], "Alice")
+
+    def test_run_with_projection(self):
+        q = self.col.where("age").gte(25)
+        result = q.run(fields=["name"])
+        self.assertEqual(len(result), 3)
+        for doc in result:
+            self.assertEqual(list(doc.keys()), ["name"])
+
+    def test_update_and_delete_and_replace(self):
+        self.col.where("name").eq("Alice").update({"updated": True})
+        updated = self.col.where("updated").eq(True).first()
+        self.assertEqual(updated["name"], "Alice")
+
+        self.col.where("name").eq("Bob").delete()
+        self.assertEqual(self.col.where("name").eq("Bob").count(), 0)
+
+        self.col.where("name").eq("Carol").replace({"name": "New", "age": 99})
+        new_doc = self.col.where("name").eq("New").first()
+        self.assertEqual(new_doc["age"], 99)
+
+    def test_aggregates(self):
+        self.assertEqual(self.col.sum("age"), 95)
+        self.assertEqual(self.col.avg("age"), 95 / 3)
+        self.assertEqual(self.col.min("age"), 25)
+        self.assertEqual(self.col.max("age"), 40)
+
+    def test_merge(self):
+        q = self.col.where("name").eq("Alice")
+        merged = q.merge(lambda d: {"new": d["age"] + 10}).run()
+        self.assertEqual(merged[0]["new"], 40)
+
+unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromTestCase(TestCollectionManager))

{coffy-0.1.2.dist-info → coffy-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coffy
-Version: 0.1.2
+Version: 0.1.5
 Summary: Lightweight local NoSQL, SQL, and Graph embedded database engine
 Author: nsarathy
 Classifier: Programming Language :: Python :: 3
@@ -24,10 +24,15 @@ Dynamic: summary
 **Coffy** is a lightweight embedded database engine for Python, designed for local-first apps, scripts, and tools. It includes:
 
 - `coffy.nosql`: A simple JSON-backed NoSQL engine with a fluent, chainable query interface  
-- `coffy.sql`: A wrapper over SQLite for executing raw SQL with clean tabular results  
-- `coffy.graph`: An graph engine built on `networkx` with advanced filtering and logic-based querying
+- `coffy.graph`: An graph engine built on `networkx` with advanced filtering and logic-based querying  
+- `coffy.sql`: A wrapper over `SQLite` for executing raw SQL  
 
-No dependencies (except `networkx`). No boilerplate. Just data.
+---
+## Latest Updates
+- Added projection and dot-notation support for nested fields in NoSQL queries. Expanded logic chaining (`_and`, `_or`, `_not`) with improved test and better query semantics.
+- GraphDB now supports saving query results, fixed relationship type serialization, and added more robust unit coverage.
+- Unit tests added to test NoSQL and Graph database features.
+- Documentation Updated.
 
 ---
 
@@ -43,31 +48,31 @@ pip install coffy
 
 ### `coffy.nosql`
 
-- JSON-based collections with fluent `.where().eq().gt()...` query chaining  
-- Joins, updates, filters, aggregation, export/import  
-- All data saved to human-readable `.json` files  
+- Embedded NoSQL document store with a fluent, chainable query API
+- Supports nested fields, logical filters, aggregations, projections, and joins
+- Built for local usage with optional persistence; minimal setup, fast iteration
 
 📄 [NoSQL Documentation →](https://github.com/nsarathy/Coffy/blob/main/NOSQL_DOCS.md)
 
 ---
 
-### `coffy.sql`
+### `coffy.graph`
 
-- SQLite-backed engine with raw SQL query support  
-- Outputs as readable tables or exportable lists  
-- Uses in-memory DB by default, or json-based if initialized with a path  
+- Lightweight, file-backed graph database using `networkx` under the hood
+- Supports pattern matching, label/type filtering, logical conditions, and projections
+- Query results can be saved, updated, or transformed; ideal for local, schema-flexible graph data
 
-📄 [SQL Documentation →](https://github.com/nsarathy/Coffy/blob/main/SQL_DOCS.md)
+📄 [Graph Documentation →](https://github.com/nsarathy/Coffy/blob/main/GRAPH_DOCS.md)
 
 ---
 
-### `coffy.graph`
+### `coffy.sql`
 
-- Wrapper around `networkx` with simplified node/relationship API  
-- Query nodes and relationships using filters like `gt`, `lt`, `eq`, `or`, `not`  
+- SQLite-backed engine with raw SQL query support  
+- Outputs as readable tables or exportable lists  
 - Uses in-memory DB by default, or json-based if initialized with a path  
 
-📄 [Graph Documentation →](https://github.com/nsarathy/Coffy/blob/main/GRAPH_DOCS.md)
+📄 [SQL Documentation →](https://github.com/nsarathy/Coffy/blob/main/SQL_DOCS.md)
 
 ---
 
@@ -81,15 +86,6 @@ users.add({"id": 1, "name": "Neel"})
 print(users.where("name").eq("Neel").first())
 ```
 
-```python
-from coffy.sql import init, query
-
-init("app.db")
-query("CREATE TABLE test (id INT, name TEXT)")
-query("INSERT INTO test VALUES (1, 'Neel')")
-print(query("SELECT * FROM test"))
-```
-
 ```python
 from coffy.graph import GraphDB
 
@@ -99,6 +95,15 @@ g.add_relationships([{"source": 1, "target": 2, "type": "friend"}])
 print(g.find_relationships(type="friend"))
 ```
 
+```python
+from coffy.sql import init, query
+
+init("app.db")
+query("CREATE TABLE test (id INT, name TEXT)")
+query("INSERT INTO test VALUES (1, 'Neel')")
+print(query("SELECT * FROM test"))
+```
+
 ---
 
 ## 📄 License

{coffy-0.1.2.dist-info → coffy-0.1.5.dist-info}/RECORD

@@ -2,15 +2,17 @@ coffy/__init__.py,sha256=Q5FwcCZtemm41gSD-n-t9zAipeh5XV7JuoBzEHze7J8,39
 coffy/__pycache__/__init__.cpython-311.pyc,sha256=Mf7ImWR3gBHSLuRr-Wf__3OsjKGpdH8D5T2qm-em5AM,150
 coffy/__pycache__/__init__.cpython-312.pyc,sha256=n_nvLEknScZM-FT6aNmDlpZGQd_ZHB3p_zRJirbI_Ic,146
 coffy/graph/__init__.py,sha256=Z0cIgmxre3YgwBrstubB1PTElP5uatz3ZOEIuW9EwY4,80
-coffy/graph/graphdb_nx.py,sha256=h9we_VSZVE_vDttuxI7msgKX7besldvp29cwRDo_8lw,4270
+coffy/graph/graph_tests.py,sha256=PmgoR2t14_2H2ynSavCmORuuxXqC5co1KWfYM1svKko,5661
+coffy/graph/graphdb_nx.py,sha256=ol4tmfTSbLm8o-i_zXOvxjKUSi5Z4h1rl2-Hd9HOBKg,13648
 coffy/graph/__pycache__/__init__.cpython-312.pyc,sha256=GCuchZzMG77ILVDNh1wX5eerxwQlrnm0VGNAqjGITXg,199
-coffy/graph/__pycache__/graphdb_nx.cpython-312.pyc,sha256=USv0c6J20Iu-meznDh2PehAlSnEU2fRxH3_9pplXj0c,8580
+coffy/graph/__pycache__/graphdb_nx.cpython-312.pyc,sha256=JSv_32YuTTsDy9Yfl3jCSUYORtH95_pL6OHTtrvf7Ts,21201
 coffy/nosql/__init__.py,sha256=HN9UfUd9pooB7udUxNn3EAttEjGG394fECOXDb6SH60,197
-coffy/nosql/engine.py,sha256=-rXYu4Ps6P_6C8nIbEpGRuDeJgAi33_FebGZNlM4jsg,10103
+coffy/nosql/engine.py,sha256=6pN9uIC_Z07ZWlIkD8g4TZv8kwjZ9RMreM41HIsa6mM,11009
+coffy/nosql/nosql_tests.py,sha256=fL7C8zm-o48CZPIA4-FPtDHsn59Ahj4zH4e6LlJFHQk,3743
 coffy/nosql/__pycache__/__init__.cpython-311.pyc,sha256=0dDD3adswuWrOOUVE_2KjO80zmOHkPAjW7pxMg4fukk,463
 coffy/nosql/__pycache__/__init__.cpython-312.pyc,sha256=NdU26hkvPHawUktm4TUoEirspFgWDMaixaQV7cGAYIc,409
 coffy/nosql/__pycache__/engine.cpython-311.pyc,sha256=lJm3ZWQbStmBV1p9pmXdrIBcf2PMPM0SGozUEHdInA8,27471
-coffy/nosql/__pycache__/engine.cpython-312.pyc,sha256=YCxgeof-6PE5SlrmDLyYLu8967UXN42vpciaUAM5XCg,24241
+coffy/nosql/__pycache__/engine.cpython-312.pyc,sha256=wzPBARp1nNbNEWhnAcHRIoI4yPxDFivFs-eGY7Db40A,25140
 coffy/sql/__init__.py,sha256=dXoCW3Qyk3WoYl-y2gHCc8YK6dAUt0Eaqhtk3PEDHMQ,202
 coffy/sql/engine.py,sha256=q9A7zvg9JANpWAFvbw8wfGY5BTkvObpM3eoQ6dZYu_8,1065
 coffy/sql/sqldict.py,sha256=0IxlCz1hi1zj5Q4_8If9YXwQBZGczpMir7PMXBOxbjs,1837
@@ -21,8 +23,8 @@ coffy/sql/__pycache__/engine.cpython-312.pyc,sha256=fKlvycKKYZOslQd6SDHexrWV_NDc
 coffy/sql/__pycache__/io.cpython-312.pyc,sha256=TPkeJ3qUE_ZcvcykGIf-Yyc0__5FZKB1J95_2yTFrXY,2517
 coffy/sql/__pycache__/sqldict.cpython-311.pyc,sha256=jJQDFH9ULzi2ay4pyXXye-W_PSjxuT_ULb20CdL8Ec0,5131
 coffy/sql/__pycache__/sqldict.cpython-312.pyc,sha256=T4P9qMjH7dHqDTp3gzZQbhpdpfgdopmC3ccm8O8gooc,4339
-coffy-0.1.2.dist-info/licenses/LICENSE,sha256=iRyxG6b7B-JPKuOcS7w5lDhrL0AD9fFSDUh6-KMKDO8,1068
-coffy-0.1.2.dist-info/METADATA,sha256=c5qu5C1bdV6hvTX1GKUPoWHu1IoPvWMIlsNCcKOE4Nw,2856
-coffy-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-coffy-0.1.2.dist-info/top_level.txt,sha256=J1zGvXA_bfET3PsE4-qbFrtFMIN3bJNxBRMHKk6YIv0,6
-coffy-0.1.2.dist-info/RECORD,,
+coffy-0.1.5.dist-info/licenses/LICENSE,sha256=iRyxG6b7B-JPKuOcS7w5lDhrL0AD9fFSDUh6-KMKDO8,1068
+coffy-0.1.5.dist-info/METADATA,sha256=9RYiM5TAqAJ8_HUsPHNGskTVgoILpI3xkCMhSdQsVU8,3256
+coffy-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+coffy-0.1.5.dist-info/top_level.txt,sha256=J1zGvXA_bfET3PsE4-qbFrtFMIN3bJNxBRMHKk6YIv0,6
+coffy-0.1.5.dist-info/RECORD,,