1 files changed, 119 insertions, 0 deletions
diff --git a/bsfs/graph/result.py b/bsfs/graph/result.py
new file mode 100644
index 0000000..0fcbb13
--- /dev/null
+++ b/bsfs/graph/result.py
@@ -0,0 +1,119 @@
+
+# imports
+from collections import defaultdict
+import typing
+
+# bsfs imports
+from bsfs.utils import URI
+
+# exports
+__all__: typing.Sequence[str] = (
+    'to_list_view',
+    'to_dict_view',
+    )
+
+
+## code ##
+
+# FIXME: node, path, value seem counter-intuitive:
+# node.get(..., node=True) removes the node part.
+# wouldn't it make more sense if node=True keeps the node part
+# and node=False drops it?
+
+def to_list_view(
+        triples,
+        # aggregators
+        node: bool,
+        path: bool,
+        value: bool, # pylint: disable=unused-argument
+        ):
+    """Return an iterator over results.
+
+    Dependent on the *node*, *path*, and *value* flags,
+    the respective component is omitted.
+
+    """
+    if not node and not path:
+        return iter(val for _, _, val in triples)
+    if not node:
+        return iter((pred, val) for _, pred, val in triples)
+    if not path:
+        return iter((subj, val) for subj, _, val in triples)
+    return iter((subj, pred, val) for subj, pred, val in triples)
+
+
+def to_dict_view(
+        triples,
+        # context
+        one_node: bool,
+        one_path: bool,
+        unique_paths: typing.Set[typing.Union[URI, typing.Iterable[URI]]],
+        # aggregators
+        node: bool,
+        path: bool,
+        value: bool,
+        default: typing.Optional[typing.Any] = None,
+        ) -> typing.Any:
+    """Return a dict of results.
+
+    Note that triples are materialized to create this view.
+
+    The returned structure depends on the *node*, *path*, and *value* flags.
+    If all flags are set to False, returns a dict(node -> dict(path -> set(values))).
+    Setting a flag to true omits or simplifies the respective component (if possible).
+
+    """
+    # NOTE: To create a dict, we need to materialize or make further assumptions
+    # (e.g., sorted in a specific order).
+
+    data: typing.Any # disable type checks on data since it's very flexibly typed.
+
+    # FIXME: type of data can be overwritten later on (if value)
+
+    if not node and not path:
+        data = set()
+    elif node ^ path:
+        data = defaultdict(set)
+    else:
+        data = defaultdict(lambda: defaultdict(set))
+
+    for subj, pred, val in triples:
+        unique = pred in unique_paths
+        if not node and not path:
+            if not value and unique and one_node and one_path:
+                return val
+            data.add(val)
+        elif not node:
+            # remove node from result, group by predicate
+            if not value and unique and one_node:
+                data[pred] = val
+            else:
+                data[pred].add(val)
+        elif not path:
+            # remove predicate from result, group by node
+            if not value and unique and one_path:
+                data[subj] = val
+            else:
+                data[subj].add(val)
+        else:
+            if not value and unique:
+                data[subj][pred] = val
+            else:
+                data[subj][pred].add(val)
+
+    # FIXME: Combine multiple Nodes instances into one?
+
+    # convert defaultdict to ordinary dict
+    # pylint: disable=too-many-boolean-expressions
+    if not node and not path and not value \
+       and len(unique_paths) > 0 and one_node and one_path \
+       and len(data) == 0:
+        return default
+    # pylint: enable=too-many-boolean-expressions
+    if not node and not path:
+        return data
+    if node ^ path:
+        return dict(data)
+    return {key: dict(val) for key, val in data.items()}
+
+## EOF ##