uco-core:Bundle should not to be used

[fabrizio-turchi]

• It is better not to use the uco-core:Bundle class to indicate the UCO/CASE version and the general description of the JSON-LD file. New properties will be introduced in next releases. Alternatively a generic ObservableObject with rdf:comments can be used inside the uco-core:object property array:
• Example:

{
    "@id": "kb:cbd39ad4-ab25-452d-b03e-10364c7fd40e",
    "@type": "uco-observable:ObservableObject",
    "rdfs:comment": "name: D.F. Expert",
    "rdfs:comment": "version: CASE 1.0.0",
    "rdfs:comment": "description: Device example complied with UCO/CASE 1.0.0"
  }

[ajnelson-nist]

(Note I do use JSON and JSON-LD distinctly below.)

The current usage of Bundle is as the root JSON object, which ends up housing the JSON-LD context dictionary.

In CASE example graphs, the root JSON object instead houses a "graph" JSON-LD structure - keys @graph and @context.

Bundle currently gives a way to list all of the involved objects being conveyed in a transit bundle, and this still has semantic relevance worth preserving. But it makes storing non-UcoObjects (e.g. types:Hash) in the graph awkward because there is a need to track whether the object has been inlined somewhere already.

If Bundle is to be removed from its current role, I think a "Graph" class (not ontological---a JSON-LD structural maintenance item) should be added to base.py, and some method added to handle adding any UcoThing to it.

[forest-savage1234]

Confirmed on main: Bundle is still the JSON-LD root. example.py builds uco.core.Bundle, which sets @context and @type uco-core:Bundle, then print(bundle).

Fabrizio's write-up is about not using Bundle to carry version / description. That part does not need a new class — an ObservableObject with rdfs:comment can already sit in uco-core:object (append_to_uco_object / append_to_rdfs_comments are already on Bundle).

Alex: if Bundle is removed from that root role, add a non-ontological Graph in base.py that can hold any UcoThing (so types:Hash does not have to be inlined-or-not against uco-core:object).

A Graph that replaces Bundle is a larger design (who owns the prefix dictionary, Hash inlining, the example). I am not opening a PR for that, and I am not dropping Bundle.

Smallest Graph that matches the thread, additive, Bundle unchanged:

class Graph(dict):
    """Non-ontological JSON-LD document. Not a UCO class. Not a Bundle.

    Holds any UcoThing under @graph. Caller supplies @context.
    """

    def __init__(self, *things: "UcoThing", context: Optional[dict] = None) -> None:
        self["@context"] = {} if context is None else context
        self["@graph"] = []
        if things:
            self.append(*things)

    def append(self, *args: "UcoThing") -> None:
        for item in args:
            if isinstance(item, UcoThing):
                self["@graph"].append(item)
            else:
                print(f"{item}: NOT A CASE OBJECT")

    def __str__(self) -> str:
        return json.dumps(self, indent=4)

No @type. json and Optional are already in base.py.

Do you want that additive Graph later without touching Bundle, or should I stand down on Graph until Bundle leaves the JSON-LD root?

I am a volunteer. Thank you for the time. I am trying to become more useful on this work, so I welcome a critical look. If this is the wrong cut, or you want me to stand down, say so and I will recut from notes.