slightly adjusted tests and fixed miniature bugs in ld_container and ld_dict

Author: notactuallyfinn

src/hermes/model/types/ld_container.py

@@ -237,7 +237,7 @@ def _to_expanded_json(
         # while searching build a path such that it leads from the found ld_dicts ld_value to selfs data_dict/ item_list
         parent = self
         path = []
-        while parent.__class__.__name__ != "ld_dict":
+        while parent.__class__.__name__ not in {"ld_dict", "SoftwareMetadata"}:
             if parent.container_type == "@list":
                 path.extend(["@list", 0])
             elif parent.container_type == "@graph":
@@ -250,7 +250,7 @@ def _to_expanded_json(
         # if neither self nor any of its parents is a ld_dict:
         # create a dict with the key of the outer most parent of self and this parents ld_value as a value
         # this dict is stored in an ld_container and simulates the most minimal JSON-LD object possible
-        if parent.__class__.__name__ != "ld_dict":
+        if parent.__class__.__name__ not in {"ld_dict", "SoftwareMetadata"}:
             key = self.ld_proc.expand_iri(parent.active_ctx, parent.key)
             parent = ld_container([{key: parent._data}])
         path.append(0)

src/hermes/model/types/ld_dict.py

@@ -22,15 +22,16 @@ def __init__(self, data, *, parent=None, key=None, index=None, context=None):
 
     def __getitem__(self, key):
         full_iri = self.ld_proc.expand_iri(self.active_ctx, key)
-        try:
-            ld_value = self.data_dict[full_iri]
-        except KeyError:
-            self.data_dict.update({full_iri: [{"@list": []}]})
-            ld_value = self.data_dict[full_iri]
+        if full_iri not in self.data_dict:
+            self[full_iri] = []
+        ld_value = self.data_dict[full_iri]
         return self._to_python(full_iri, ld_value)
 
     def __setitem__(self, key, value):
         full_iri = self.ld_proc.expand_iri(self.active_ctx, key)
+        if value is None:
+            del self[full_iri]
+            return
         ld_value = self._to_expanded_json({full_iri: value})
         self.data_dict.update(ld_value)
 
@@ -40,7 +41,8 @@ def __delitem__(self, key):
 
     def __contains__(self, key):
         full_iri = self.ld_proc.expand_iri(self.active_ctx, key)
-        return len(self[full_iri]) != 0
+        # FIXME: is that good?
+        return full_iri in self.data_dict
 
     def __eq__(self, other):
         if not isinstance(other, (dict, ld_dict)):
@@ -79,9 +81,12 @@ def __ne__(self, other):
         return not x
 
     def get(self, key, default=_NO_DEFAULT):
-        if key not in self and default is not ld_dict._NO_DEFAULT:
+        try:
+            return self[key]
+        except KeyError as e:
+            if default is self._NO_DEFAULT:
+                raise e
             return default
-        return self[key]
 
     def update(self, other):
         for key, value in other.items():

test/hermes_test/model/test_api.py

@@ -44,29 +44,32 @@ def test_init_nested_object():
         "author": [{"name": "Foo"}, {"name": "Bar"}],
     }
     data = SoftwareMetadata(my_software, extra_vocabs={"foo": "https://foo.bar"})
-    assert data["schema:softwareName"][0] == "MySoftware"
-    assert data["maintainer"][0]["name"][0] == "Some Name"
+    assert data["schema:softwareName"] == ["MySoftware"]
+    assert len(data["maintainer"]) == 1 and data["maintainer"][0]["name"] == ["Some Name"]
     for author in data["author"]:
         for name in author["name"]:
             assert name in ["Foo", "Bar"]
 
 
 def test_append():
     data = SoftwareMetadata()
-    data["foo"].append("a")
-    assert type(data["foo"]) is ld_list and data["foo"][0] == "a" and data["foo"].item_list == [{"@value": "a"}]
-    data["foo"].append("b")
-    assert type(data["foo"]) is ld_list and data["foo"].item_list == [{"@value": "a"}, {"@value": "b"}]
-    data["foo"].append("c")
-    assert data["foo"].item_list == [{"@value": "a"}, {"@value": "b"}, {"@value": "c"}]
+    data["schema:foo"].append("a")
+    assert type(data["schema:foo"]) is ld_list
+    assert data["schema:foo"][0] == "a" and data["schema:foo"].item_list == [{"@value": "a"}]
+    data["schema:foo"].append("b")
+    assert type(data["schema:foo"]) is ld_list
+    assert data["schema:foo"] == [{"@value": "a"}, {"@value": "b"}]
+    data["schema:foo"].append("c")
+    assert data["schema:foo"] == [{"@value": "a"}, {"@value": "b"}, {"@value": "c"}]
     data = SoftwareMetadata()
-    data["foo"].append({"schema:name": "foo"})
-    assert type(data["foo"]) is ld_list and type(data["foo"][0]) is ld_dict
-    assert data["foo"][0].data_dict == {"http://schema.org/name": [{"@value": "foo"}]}
-    data["foo"].append({"schema:name": "foo"})
-    assert type(data["foo"]) is ld_list and data["foo"].item_list == 2*[{"http://schema.org/name": [{"@value": "foo"}]}]
-    data["foo"].append({"schema:name": "foo"})
-    assert data["foo"].item_list == 3 * [{"http://schema.org/name": [{"@value": "foo"}]}]
+    data["schema:foo"].append({"schema:name": "bar"})
+    assert type(data["schema:foo"]) is ld_list and type(data["schema:foo"][0]) is ld_dict
+    assert data["schema:foo"] == [{"http://schema.org/name": [{"@value": "bar"}]}]
+    data["schema:foo"].append({"schema:name": "bar"})
+    assert type(data["schema:foo"]) is ld_list
+    assert data["schema:foo"] == 2 * [{"http://schema.org/name": [{"@value": "bar"}]}]
+    data["schema:foo"].append({"schema:name": "bar"})
+    assert data["schema:foo"] == 3 * [{"http://schema.org/name": [{"@value": "bar"}]}]
 
 
 def test_iterative_assignment():
@@ -78,9 +81,10 @@ def test_iterative_assignment():
     assert isinstance(authors, ld_list)
     author1 = authors[0]
     author1["email"] = "[email protected]"
-    authors[0] = author1
     authors.append({"name": "Bar", "email": "[email protected]"})
     assert len(authors) == 2
+    del authors[0]
+    assert len(authors) == 1
 
 
 def test_usage():
@@ -95,38 +99,38 @@ def test_usage():
     harvest = {
         "authors": [
             {"name": "Foo", "affiliation": ["Uni A", "Lab B"], "kw": ["a", "b", "c"]},
-            {"name": "Bar", "affiliation": ["Uni C"], "email": "[email protected]"},
+            {"name": "Bar", "affiliation": ["Uni C"], "email": "[email protected]", "kw": "egg"},
             {"name": "Baz", "affiliation": ["Lab E"]},
         ]
     }
     for author in harvest["authors"]:
         for exist_author in data["author"]:
-            if author["name"] == exist_author["name"][0]:
-                exist_author["affiliation"] = author["affiliation"]
-                if "email" in author:
-                    exist_author["email"].append(author["email"])
-                if "kw" in author:
-                    exist_author["schema:knowsAbout"].extend(author["kw"])
+            if author["name"] in exist_author["name"]:
+                exist_author["affiliation"] = author.get("affiliation", [])
+                exist_author["email"].extend(email if isinstance((email := author.get("email", [])), list) else [email])
+                exist_author["schema:knowsAbout"].extend(kw if isinstance((kw := author.get("kw", [])), list) else [kw])
                 break
         else:
             data["author"].append(author)
     assert len(data["author"]) == 3
     foo, bar, baz = data["author"]
     assert foo["name"][0] == "Foo"
-    assert foo["affiliation"].to_python() == ["Uni A", "Lab B"]
-    assert foo["schema:knowsAbout"].to_python() == ["a", "b", "c"]
-    assert foo["email"].to_python() == ["[email protected]", "[email protected]"]
+    assert foo["affiliation"] == ["Uni A", "Lab B"]
+    assert foo["schema:knowsAbout"] == ["a", "b", "c"]
+    assert foo["email"] == ["[email protected]", "[email protected]"]
     assert bar["name"][0] == "Bar"
-    assert bar["affiliation"].to_python() == ["Uni C"]
-    assert bar["email"].to_python() == ["[email protected]"]
+    assert bar["affiliation"] == ["Uni C"]
+    assert bar["email"] == ["[email protected]"]
     assert baz["name"][0] == "Baz"
-    assert baz["affiliation"].to_python() == ["Lab E"]
+    assert baz["affiliation"] == ["Lab E"]
     assert len(baz["schema:knowsAbout"]) == 0
     assert len(baz["email"]) == 0
     for author in data["author"]:
         assert "name" in author
         assert "email" in author
-        if "schema:knowsAbout" not in author:
+        if author["schema:knowsAbout"] == ["egg"]:
             # FIXME: None has to be discussed
+            # json-ld processor just removes it in expansion
             author["schema:knowsAbout"] = None
         author["schema:pronouns"] = "they/them"
+    assert len(bar["schema:knowsAbout"]) == 0

test/hermes_test/model/types/test_ld_dict.py

@@ -189,8 +189,10 @@ def test_get():
                  context=[{"schema": "https://schema.org/"}])
     assert di.get("https://schema.org/name") == ["Manu Sporny"]
     assert di.get("schema:name") == ["Manu Sporny"]
-    assert di.get("bar", None) is None
-    assert isinstance(di["bar"], ld_list) and len(di["bar"]) == 0
+    assert di.get("bar", None) is None  # invalid key
+    with pytest.raises(KeyError):
+        di.get("bar")
+    assert isinstance(di.get("schema:bar", None), ld_list) and len(di.get("schema:bar", None)) == 0
 
 
 def test_update():