cleaned up __init__.py

Author: Michael Fritzsche

src/hermes/model/types/__init__.py

@@ -5,29 +5,19 @@
 # SPDX-FileContributor: Michael Meinel
 # SPDX-FileContributor: Michael Fritzsche
 
-from datetime import date, time, datetime
-
 from .ld_container import ld_container
-from .ld_list import ld_list
 from .ld_dict import ld_dict
-from .ld_context import iri_map
+from .ld_list import ld_list
 from .pyld_util import JsonLdProcessor
 
 
 _TYPEMAP = [
-    # Conversion routines for ld_container
-    (
-        lambda c: isinstance(c, ld_container),
-        {
-            "ld_container": lambda c, **_: c,
-            "json": lambda c, **_: c.compact(),
-            "expanded_json": lambda c, **_: c.ld_value,
-        },
-    ),
+    # Conversion routine for ld_container
+    (lambda c: isinstance(c, ld_container), {"ld_container": lambda c, **_: c}),
 
     # Wrap item from ld_dict in ld_list
     (ld_list.is_ld_list, {"ld_container": ld_list}),
-    (lambda c: isinstance(c, list), {"ld_container": lambda c, **kw: ld_list(c, **kw)}),
+    (lambda c: isinstance(c, list), {"ld_container": ld_list}),
 
     # pythonize items from lists (expanded set is already handled above)
     (ld_container.is_json_id, {"python": lambda c, **_: c["@id"]}),
@@ -36,35 +26,6 @@
     (ld_list.is_container, {"ld_container": lambda c, **kw: ld_list([c], **kw)}),
     (ld_dict.is_json_dict, {"ld_container": lambda c, **kw: ld_dict([c], **kw)}),
     (lambda v: isinstance(v, str), {"python": lambda v, parent, **_: parent.ld_proc.compact_iri(parent.active_ctx, v)}),
-
-    # Convert internal data types to expanded_json
-    (ld_container.is_json_id, {"expanded_json": lambda c, **_: [c]}),
-    (ld_container.is_ld_id, {"expanded_json": lambda c, **_: c}),
-    (ld_container.is_json_value, {"expanded_json": lambda c, **_: [c]}),
-    (ld_container.is_ld_value, {"expanded_json": lambda c, **_: c}),
-    (ld_dict.is_json_dict, {"expanded_json": lambda c, **kw: ld_dict.from_dict(c, **kw).ld_value}),
-    (
-        ld_list.is_container,
-        {"expanded_json": lambda c, **kw: ld_list.from_list(ld_list.get_item_list_from_container(c), **kw).ld_value}
-    ),
-    (
-        ld_list.is_ld_list,
-        {"expanded_json": lambda c, **kw: ld_list.from_list(ld_list.get_item_list_from_container(c[0]), **kw).ld_value}
-    ),
-    (lambda c: isinstance(c, list), {"expanded_json": lambda c, **kw: ld_list.from_list(c, **kw).ld_value}),
-    (lambda v: isinstance(v, (int, float, str, bool)), {"expanded_json": lambda v, **_: [{"@value": v}]}),
-    (
-        lambda v: isinstance(v, datetime),
-        {"expanded_json": lambda v, **_: [{"@value": v.isoformat(), "@type": iri_map["schema:DateTime"]}]}
-    ),
-    (
-        lambda v: isinstance(v, date),
-        {"expanded_json": lambda v, **_: [{"@value": v.isoformat(), "@type": iri_map["schema:Date"]}]}
-    ),
-    (
-        lambda v: isinstance(v, time),
-        {"expanded_json": lambda v, **_: [{"@value": v.isoformat(), "@type": iri_map["schema:Time"]}]}
-    ),
 ]
 
 

src/hermes/model/types/ld_dict.py

@@ -65,12 +65,7 @@ def __eq__(self, other):
         if unique_keys and unique_keys != {"@id"}:
             return False
         for key in keys_self.intersection(keys_other):
-            item = self[key]
-            other_item = other[key]
-            res = item.__eq__(other_item)
-            if res == NotImplemented:
-                res = other_item.__eq__(item)
-            if res is False or res == NotImplemented:  # res is not True
+            if self[key] != other[key]:
                 return False
         return True
 

src/hermes/model/types/ld_list.py

@@ -312,16 +312,8 @@ def __eq__(
                     if item["@id"] != other_item["@id"]:
                         return False
                     continue
-                # get the 'real' items (i.e. can also be ld_dicts or ld_lists)
-                item = self[index]
-                other_item = other[index]
-                # compare using the correct equals method
-                res = item.__eq__(other_item)
-                if res == NotImplemented:
-                    # swap order if first try returned NotImplemented
-                    res = other_item.__eq__(item)
-                # return false if the second comparison also fails or one of them returned false
-                if res is False or res == NotImplemented:
+                # compare the 'real' items (i.e. can also be ld_dicts or ld_lists)
+                if self[index] != other[index]:
                     return False
             # return true because no unequal elements where found
             return True
@@ -341,16 +333,8 @@ def __eq__(
                         if item["@id"] == other_item["@id"]:
                             equality_pairs[index] += [other_index]
                         continue
-                    # get the 'real' items (i.e. can also be ld_dicts or ld_lists)
-                    item = self[index]
-                    other_item = other[index]
-                    # compare using the correct equals method
-                    res = item.__eq__(other_item)
-                    if res == NotImplemented:
-                        # swap order if first try returned NotImplemented
-                        res = other_item.__eq__(item)
-                    # if one of both comparisons returned true the elements are equal
-                    if res is not NotImplemented and res:
+                    # compare the 'real' items (i.e. can also be ld_dicts or ld_lists)
+                    if self[index] == other[other_index]:
                         equality_pairs[index] += [other_index]
                 if len(equality_pairs[index]) == 0:
                     # there exists no element in other that is equal to item