new: use _graphs instead of nxadb_graphs

Author: aMahanna

nx_arangodb/classes/dict/adj.py

@@ -1815,7 +1815,7 @@ def propagate_edge_directed_symmetric(
                 set_adj_inner_dict_mirror(src_node_id)
                 set_adj_inner_dict_mirror(dst_node_id)
 
-                edge_attr_or_key_dict = set_edge_func(  # type: ignore[operator]
+                edge_attr_or_key_dict = set_edge_func(
                     src_node_id, dst_node_id, edge_or_edges
                 )
 

nx_arangodb/classes/dict/graph.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from collections import UserDict
 from typing import Any, Callable
 
@@ -39,6 +40,8 @@ def graph_attr_dict_factory(
 # Graph #
 #########
 
+GRAPH_KEY = "networkx"
+
 
 def build_graph_attr_dict_data(
     parent: GraphAttrDict, data: dict[str, Any]
@@ -104,7 +107,11 @@ class GraphDict(UserDict[str, Any]):
     Given that ArangoDB does not have a concept of graph attributes, this class
     stores the attributes in a collection with the graph name as the document key.
 
-    For now, the collection is called 'nxadb_graphs'.
+    The default collection is called `_graphs`. However, if the
+    `DATABASE_GRAPH_COLLECTION_NAME` environment variable is specified,
+    then that collection will be used. This variable is useful when the
+    database user does not have permission to access the `_graphs`
+    system collection.
 
     Parameters
     ----------
@@ -123,31 +130,41 @@ class GraphDict(UserDict[str, Any]):
     >>> del G.graph['foo']
     """
 
-    def __init__(self, db: StandardDatabase, graph: Graph, *args: Any, **kwargs: Any):
+    def __init__(
+        self,
+        db: StandardDatabase,
+        graph: Graph,
+        *args: Any,
+        **kwargs: Any,
+    ):
         super().__init__(*args, **kwargs)
         self.data: dict[str, Any] = {}
 
         self.db = db
         self.adb_graph = graph
         self.graph_name = graph.name
-        self.COLLECTION_NAME = "nxadb_graphs"
-        self.graph_id = f"{self.COLLECTION_NAME}/{self.graph_name}"
+        self.collection_name = os.environ.get(
+            "DATABASE_GRAPHS_COLLECTION_NAME", "_graphs"
+        )
 
-        self.collection = create_collection(db, self.COLLECTION_NAME)
+        self.graph_id = f"{self.collection_name}/{self.graph_name}"
+        self.parent_keys = [GRAPH_KEY]
+
+        self.collection = create_collection(db, self.collection_name)
         self.graph_attr_dict_factory = graph_attr_dict_factory(
             self.db, self.adb_graph, self.graph_id
         )
 
-        result = doc_get_or_insert(self.db, self.COLLECTION_NAME, self.graph_id)
-        for k, v in result.items():
+        result = doc_get_or_insert(self.db, self.collection_name, self.graph_id)
+        for k, v in result.get(GRAPH_KEY, {}).items():
             self.data[k] = self.__process_graph_dict_value(k, v)
 
     def __process_graph_dict_value(self, key: str, value: Any) -> Any:
         if not isinstance(value, dict):
             return value
 
         graph_attr_dict = self.graph_attr_dict_factory()
-        graph_attr_dict.parent_keys = [key]
+        graph_attr_dict.parent_keys += [key]
         graph_attr_dict.data = build_graph_attr_dict_data(graph_attr_dict, value)
 
         return graph_attr_dict
@@ -158,7 +175,7 @@ def __contains__(self, key: str) -> bool:
         if key in self.data:
             return True
 
-        return aql_doc_has_key(self.db, self.graph_id, key)
+        return aql_doc_has_key(self.db, self.graph_id, key, self.parent_keys)
 
     @key_is_string
     def __getitem__(self, key: str) -> Any:
@@ -167,7 +184,7 @@ def __getitem__(self, key: str) -> Any:
         if value := self.data.get(key):
             return value
 
-        result = aql_doc_get_key(self.db, self.graph_id, key)
+        result = aql_doc_get_key(self.db, self.graph_id, key, self.parent_keys)
 
         if result is None:
             raise KeyError(key)
@@ -187,14 +204,17 @@ def __setitem__(self, key: str, value: Any) -> None:
 
         graph_dict_value = self.__process_graph_dict_value(key, value)
         self.data[key] = graph_dict_value
-        doc_update(self.db, self.graph_id, {key: value})
+
+        update_dict = get_update_dict(self.parent_keys, {key: value})
+        doc_update(self.db, self.graph_id, update_dict)
 
     @key_is_string
     @key_is_not_reserved
     def __delitem__(self, key: str) -> None:
         """del G.graph['foo']"""
         self.data.pop(key, None)
-        doc_update(self.db, self.graph_id, {key: None})
+        update_dict = get_update_dict(self.parent_keys, {key: None})
+        doc_update(self.db, self.graph_id, update_dict)
 
     # @values_are_json_serializable # TODO?
     def update(self, attrs: Any) -> None:  # type: ignore
@@ -208,7 +228,8 @@ def update(self, attrs: Any) -> None:  # type: ignore
         graph_attr_dict.data = graph_attr_dict_data
 
         self.data.update(graph_attr_dict_data)
-        doc_update(self.db, self.graph_id, attrs)
+        update_dict = get_update_dict(self.parent_keys, attrs)
+        doc_update(self.db, self.graph_id, update_dict)
 
     def clear(self) -> None:
         """G.graph.clear()"""
@@ -256,7 +277,7 @@ def __init__(
         self.graph = graph
         self.graph_id: str = graph_id
 
-        self.parent_keys: list[str] = []
+        self.parent_keys: list[str] = [GRAPH_KEY]
         self.graph_attr_dict_factory = graph_attr_dict_factory(
             self.db, self.graph, self.graph_id
         )

tests/test.py

@@ -1655,32 +1655,32 @@ def test_graph_dict_init_extended(load_karate_graph: Any) -> None:
     G = nxadb.Graph(name="KarateGraph", foo="bar", bar={"baz": True})
     G.graph["foo"] = "!!!"
     G.graph["bar"]["baz"] = False
-    assert db.document(G.graph.graph_id)["foo"] == "!!!"
-    assert db.document(G.graph.graph_id)["bar"]["baz"] is False
-    assert "baz" not in db.document(G.graph.graph_id)
+    assert db.document(G.graph.graph_id)["networkx"]["foo"] == "!!!"
+    assert db.document(G.graph.graph_id)["networkx"]["bar"]["baz"] is False
+    assert "baz" not in db.document(G.graph.graph_id)["networkx"]
 
 
 def test_graph_dict_clear_will_not_remove_remote_data(load_karate_graph: Any) -> None:
-    G_adb = nxadb.Graph(
+    G = nxadb.Graph(
         name="KarateGraph",
         foo="bar",
         bar={"a": 4},
     )
 
-    G_adb.graph["ant"] = {"b": 5}
-    G_adb.graph["ant"]["b"] = 6
-    G_adb.clear()
+    G.graph["ant"] = {"b": 5}
+    G.graph["ant"]["b"] = 6
+    G.clear()
     try:
-        G_adb.graph["ant"]
+        G.graph["ant"]
     except KeyError:
         raise AssertionError("Not allowed to fail.")
 
-    assert db.document(G_adb.graph.graph_id)["ant"] == {"b": 6}
+    assert db.document(G.graph.graph_id)["networkx"]["ant"] == {"b": 6}
 
 
 def test_graph_dict_set_item(load_karate_graph: Any) -> None:
     name = "KarateGraph"
-    db.collection("nxadb_graphs").delete(name, ignore_missing=True)
+    db.collection("_graphs").delete(name, ignore_missing=True)
     G = nxadb.Graph(name=name, default_node_type="person")
 
     json_values = [
@@ -1699,10 +1699,10 @@ def test_graph_dict_set_item(load_karate_graph: Any) -> None:
         G.graph["json"] = value
 
         if value is None:
-            assert "json" not in db.document(G.graph.graph_id)
+            assert "json" not in db.document(G.graph.graph_id)["networkx"]
         else:
             assert G.graph["json"] == value
-            assert db.document(G.graph.graph_id)["json"] == value
+            assert db.document(G.graph.graph_id)["networkx"]["json"] == value
 
 
 def test_graph_dict_update(load_karate_graph: Any) -> None:
@@ -1718,7 +1718,7 @@ def test_graph_dict_update(load_karate_graph: Any) -> None:
     assert G.graph["c"] == "d"
 
     # remote
-    adb_doc = db.collection("nxadb_graphs").get(G.name)
+    adb_doc = db.collection("_graphs").get(G.name)
     assert adb_doc["a"] == "b"
     assert adb_doc["c"] == "d"
 
@@ -1731,8 +1731,8 @@ def test_graph_attr_dict_nested_update(load_karate_graph: Any) -> None:
     G.graph["a"].update({"d": "e"})
     assert G.graph["a"]["b"] == "c"
     assert G.graph["a"]["d"] == "e"
-    assert db.document(G.graph.graph_id)["a"]["b"] == "c"
-    assert db.document(G.graph.graph_id)["a"]["d"] == "e"
+    assert db.document(G.graph.graph_id)["networkx"]["a"]["b"] == "c"
+    assert db.document(G.graph.graph_id)["networkx"]["a"]["d"] == "e"
 
 
 def test_graph_dict_nested_1(load_karate_graph: Any) -> None:
@@ -1742,7 +1742,7 @@ def test_graph_dict_nested_1(load_karate_graph: Any) -> None:
 
     G.graph["a"] = {"b": icon}
     assert G.graph["a"]["b"] == icon
-    assert db.document(G.graph.graph_id)["a"]["b"] == icon
+    assert db.document(G.graph.graph_id)["networkx"]["a"]["b"] == icon
 
 
 def test_graph_dict_nested_2(load_karate_graph: Any) -> None:
@@ -1754,7 +1754,7 @@ def test_graph_dict_nested_2(load_karate_graph: Any) -> None:
     G.graph["x"]["y"]["amount_of_goals"] = 1337
 
     assert G.graph["x"]["y"]["amount_of_goals"] == 1337
-    assert db.document(G.graph.graph_id)["x"]["y"]["amount_of_goals"] == 1337
+    assert db.document(G.graph.graph_id)["networkx"]["x"]["y"]["amount_of_goals"] == 1337
 
 
 def test_graph_dict_empty_values(load_karate_graph: Any) -> None:
@@ -1763,10 +1763,10 @@ def test_graph_dict_empty_values(load_karate_graph: Any) -> None:
 
     G.graph["empty"] = {}
     assert G.graph["empty"] == {}
-    assert db.document(G.graph.graph_id)["empty"] == {}
+    assert db.document(G.graph.graph_id)["networkx"]["empty"] == {}
 
     G.graph["none"] = None
-    assert "none" not in db.document(G.graph.graph_id)
+    assert "none" not in db.document(G.graph.graph_id)["networkx"]
     assert "none" not in G.graph
 
 
@@ -1779,12 +1779,12 @@ def test_graph_dict_nested_overwrite(load_karate_graph: Any) -> None:
     G.graph["a"] = {"b": icon1}
     G.graph["a"]["b"]["football_icon"] = "ChangedIcon"
     assert G.graph["a"]["b"]["football_icon"] == "ChangedIcon"
-    assert db.document(G.graph.graph_id)["a"]["b"]["football_icon"] == "ChangedIcon"
+    assert db.document(G.graph.graph_id)["networkx"]["a"]["b"]["football_icon"] == "ChangedIcon"
 
     # Overwrite entire nested dictionary
     G.graph["a"] = {"b": icon2}
     assert G.graph["a"]["b"]["basketball_icon"] == "MJ23"
-    assert db.document(G.graph.graph_id)["a"]["b"]["basketball_icon"] == "MJ23"
+    assert db.document(G.graph.graph_id)["networkx"]["a"]["b"]["basketball_icon"] == "MJ23"
 
 
 def test_graph_dict_complex_nested(load_karate_graph: Any) -> None:
@@ -1796,7 +1796,7 @@ def test_graph_dict_complex_nested(load_karate_graph: Any) -> None:
     G.graph["complex"] = complex_structure
     assert G.graph["complex"]["level1"]["level2"]["level3"]["key"] == "value"
     assert (
-        db.document(G.graph.graph_id)["complex"]["level1"]["level2"]["level3"]["key"]
+        db.document(G.graph.graph_id)["networkx"]["complex"]["level1"]["level2"]["level3"]["key"]
         == "value"
     )
 
@@ -1809,12 +1809,12 @@ def test_graph_dict_nested_deletion(load_karate_graph: Any) -> None:
     G.graph["x"] = {"y": icon}
     del G.graph["x"]["y"]["amount_of_goals"]
     assert "amount_of_goals" not in G.graph["x"]["y"]
-    assert "amount_of_goals" not in db.document(G.graph.graph_id)["x"]["y"]
+    assert "amount_of_goals" not in db.document(G.graph.graph_id)["networkx"]["x"]["y"]
 
     # Delete top-level key
     del G.graph["x"]
     assert "x" not in G.graph
-    assert "x" not in db.document(G.graph.graph_id)
+    assert "x" not in db.document(G.graph.graph_id)["networkx"]
 
 
 def test_readme(load_karate_graph: Any) -> None:

tests/test_graph.py

@@ -463,11 +463,11 @@ def test_graph_attr(self):
         assert isinstance(G.graph, GraphDict)
         assert G.graph["foo"] == "bar"
         del G.graph["foo"]
-        graph_doc = get_doc(f"nxadb_graphs/{GRAPH_NAME}")
+        graph_doc = get_doc(f"_graphs/{GRAPH_NAME}")
         assert G.graph == graph_doc
         H = self.K3Graph(foo="bar")
         assert H.graph["foo"] == "bar"
-        graph_doc = get_doc(f"nxadb_graphs/{GRAPH_NAME}")
+        graph_doc = get_doc(f"_graphs/{GRAPH_NAME}")
         assert H.graph == graph_doc
 
     def test_node_attr(self):