coffy 0.1.1__tar.gz → 0.1.4__tar.gz

{coffy-0.1.1/coffy.egg-info → coffy-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coffy
-Version: 0.1.1
+Version: 0.1.4
 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 →](./NOSQL_DOCS.md)
+📄 [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 →](./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 →](./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.4/README.md

@@ -0,0 +1,90 @@
+# ☕ Coffy
+
+**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.graph`: An graph engine built on `networkx` with advanced filtering and logic-based querying  
+- `coffy.sql`: A wrapper over `SQLite` for executing raw SQL  
+
+---
+## 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.
+
+---
+
+## 🔧 Install
+
+```bash
+pip install coffy
+```
+
+---
+
+## 📂 Modules
+
+### `coffy.nosql`
+
+- 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.graph`
+
+- 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
+
+📄 [Graph Documentation →](https://github.com/nsarathy/Coffy/blob/main/GRAPH_DOCS.md)
+
+---
+
+### `coffy.sql`
+
+- 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  
+
+📄 [SQL Documentation →](https://github.com/nsarathy/Coffy/blob/main/SQL_DOCS.md)
+
+---
+
+## 🧪 Example
+
+```python
+from coffy.nosql import db
+
+users = db("users", path="users.json")
+users.add({"id": 1, "name": "Neel"})
+print(users.where("name").eq("Neel").first())
+```
+
+```python
+from coffy.graph import GraphDB
+
+g = GraphDB(directed=True)
+g.add_nodes([{"id": 1, "name": "Neel"}, {"id": 2, "name": "Tanaya"}])
+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
+
+MIT © 2025 nsarathy

coffy-0.1.4/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))