h5rdmtoolbox 2.7.1__tar.gz → 2.7.3__tar.gz

{h5rdmtoolbox-2.7.1 → h5rdmtoolbox-2.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h5rdmtoolbox
-Version: 2.7.1
+Version: 2.7.3
 Summary: Supporting a FAIR Research Data lifecycle using Python and HDF5.
 Author-email: Matthias Probst <matth.probst@gmail.com>
 License-Expression: MIT
@@ -120,46 +120,117 @@ M4I = rdflib.Namespace("http://w3id.org/nfdi4ing/metadata4ing#")
 
 # Create a new HDF5 file with FAIR metadata
 with h5tbx.File("example.h5", "w") as h5:
-    h5.create_dataset("temperature", data=np.array([20, 21, 19, 22]))
-    h5.attrs["units", M4I.hasUnit] = "degree_Celsius"
-    h5.rdf["units"].object = "http://qudt.org/vocab/unit/DEG_C"
-    h5.attrs["description", "https://schema.org/description"] = "Room temperature measurements"
+    ds = h5.create_dataset("temperature", data=np.array([20, 21, 19, 22]))
+    ds.attrs["units"] = h5tbx.Attribute(
+        value="degree_Celsius",
+        rdf_predicate=M4I.hasUnit,
+        rdf_object="http://qudt.org/vocab/unit/DEG_C",
+    )
+    ds.attrs["description", "https://schema.org/description"] = "Room temperature measurements"
+
+    ds_mean = h5.create_dataset("mean_temperature", data=np.mean(h5["temperature"][()]))
+    ds_mean.attrs["units", M4I.hasUnit] = "degree_Celsius"
+    ds_mean.rdf["units"].object = "http://qudt.org/vocab/unit/DEG_C"
+    ds_mean.attrs["description", "https://schema.org/description"] = "Mean room temperature measurements"
+
+    ds_mean.rdf.type = M4I.NumericalVariable
+    ds_mean.rdf.data_predicate = M4I.hasNumericalValue
+
+    ttl_ctx = h5.serialize("ttl", structural=False, contextual=True, file_uri="https://example.org#example.h5/")
+    ttl_struc = h5.serialize("ttl", structural=True, contextual=False, file_uri="https://example.org#example.h5/")
+    ttl_full = h5.serialize("ttl", file_uri="https://example.org#example.h5/")
+```
 
-    ttl = h5.serialize("ttl")
+The above saves three different serializations of the HDF5 content as RDF in Turtle (ttl) format.
+The first one (`ttl_ctx`) is the **contextual** RDF serialization, which only includes the RDF triples that the user
+has enriched the HDF5 file with. The second one (`ttl_struc`) is the **structural** RDF serialization, which includes 
+all RDF triples that can be derived from the HDF5 file content. the third one (`ttl_full`) is the combination of the 
+first two, which includes both the user enriched RDF triples and the RDF triples that can be derived from the HDF5 file 
+content.
 
-```
-The serialization in Turtle (ttl) is teh RDF serialization of the HDF5 data (without arrays):
+Below we show the first two serializations.
+
+`ttl_ctx`:
 ```ttl
-@prefix hdf: <http://purl.allotrope.org/ontologies/hdf5/1.8#> .
 @prefix m4i: <http://w3id.org/nfdi4ing/metadata4ing#> .
 @prefix schema: <https://schema.org/> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
+<https://example.org#example.h5/example.h5/mean_temperature> a m4i:NumericalVariable ;
+    m4i:hasNumericalValue "20.5"^^xsd:float ;
+    m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
+    schema:description "Mean room temperature measurements" .
+
+<https://example.org#example.h5/example.h5/temperature> m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
+    schema:description "Room temperature measurements" .
+```
+
+`ttl_ctx`:
+```ttl
+@prefix hdf: <http://purl.allotrope.org/ontologies/hdf5/1.8#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+<https://example.org#example.h5/example.h5> a hdf:File ;
+    hdf:rootGroup <https://example.org#example.h5/example.h5/> .
+
+hdf:H5T_IEEE_F64LE a hdf:Datatype .
+
 hdf:H5T_INTEL_I64 a hdf:Datatype .
 
-[] a hdf:File ;
-    hdf:rootGroup [ a hdf:Group ;
-            hdf:attribute [ a hdf:StringAttribute ;
-                    hdf:data "Room temperature measurements" ;
-                    hdf:name "description" ],
-                [ a hdf:StringAttribute ;
-                    hdf:data "degree_Celsius" ;
-                    hdf:name "units" ] ;
-            hdf:member [ a hdf:Dataset ;
-                    hdf:dataspace [ a hdf:SimpleDataspace ;
-                            hdf:dimension [ a hdf:DataspaceDimension ;
-                                    hdf:dimensionIndex 0 ;
-                                    hdf:size 4 ] ] ;
-                    hdf:datatype hdf:H5T_INTEGER,
-                        hdf:H5T_INTEL_I64 ;
-                    hdf:layout hdf:H5D_CONTIGUOUS ;
-                    hdf:maximumSize 4 ;
-                    hdf:name "/temperature" ;
-                    hdf:rank 1 ;
-                    hdf:size 4 ] ;
-            hdf:name "/" ;
-            m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
-            schema:description "Room temperature measurements" ] .
+<https://example.org#example.h5/example.h5/> a hdf:Group ;
+    hdf:member <https://example.org#example.h5/example.h5/mean_temperature>,
+        <https://example.org#example.h5/example.h5/temperature> ;
+    hdf:name "/" .
+
+<https://example.org#example.h5/example.h5/mean_temperature> a hdf:Dataset ;
+    hdf:attribute <https://example.org#example.h5/example.h5/mean_temperature@description>,
+        <https://example.org#example.h5/example.h5/mean_temperature@units> ;
+    hdf:dataspace <https://example.org#example.h5/example.h5/mean_temperature__dataspace> ;
+    hdf:datatype hdf:H5T_FLOAT,
+        hdf:H5T_IEEE_F64LE ;
+    hdf:layout hdf:H5D_CONTIGUOUS ;
+    hdf:maximumSize -1 ;
+    hdf:name "/mean_temperature" ;
+    hdf:rank 0 ;
+    hdf:size 1 ;
+    hdf:value 2.05e+01 .
+
+<https://example.org#example.h5/example.h5/mean_temperature@description> a hdf:StringAttribute ;
+    hdf:data "Mean room temperature measurements" ;
+    hdf:name "description" .
+
+<https://example.org#example.h5/example.h5/mean_temperature@units> a hdf:StringAttribute ;
+    hdf:data "degree_Celsius" ;
+    hdf:name "units" .
+
+<https://example.org#example.h5/example.h5/mean_temperature__dataspace> a hdf:ScalarDataspace .
+
+<https://example.org#example.h5/example.h5/temperature> a hdf:Dataset ;
+    hdf:attribute <https://example.org#example.h5/example.h5/temperature@description>,
+        <https://example.org#example.h5/example.h5/temperature@units> ;
+    hdf:dataspace <https://example.org#example.h5/example.h5/temperature__dataspace> ;
+    hdf:datatype hdf:H5T_INTEGER,
+        hdf:H5T_INTEL_I64 ;
+    hdf:layout hdf:H5D_CONTIGUOUS ;
+    hdf:maximumSize 4 ;
+    hdf:name "/temperature" ;
+    hdf:rank 1 ;
+    hdf:size 4 .
+
+<https://example.org#example.h5/example.h5/temperature@description> a hdf:StringAttribute ;
+    hdf:data "Room temperature measurements" ;
+    hdf:name "description" .
+
+<https://example.org#example.h5/example.h5/temperature@units> a hdf:StringAttribute ;
+    hdf:data "degree_Celsius" ;
+    hdf:name "units" .
+
+<https://example.org#example.h5/example.h5/temperature__dataspace> a hdf:SimpleDataspace ;
+    hdf:dimension <https://example.org#example.h5/example.h5/temperature__dataspace_dimension_0> .
+
+<https://example.org#example.h5/example.h5/temperature__dataspace_dimension_0> a hdf:DataspaceDimension ;
+    hdf:dimensionIndex 0 ;
+    hdf:size 4 .
 ```
 
 [//]: # (The "HDF5 Research Data Management Toolbox" &#40;h5RDMtoolbox&#41; is a Python package supporting everybody who is working with)

{h5rdmtoolbox-2.7.1 → h5rdmtoolbox-2.7.3}/README.md

@@ -38,46 +38,117 @@ M4I = rdflib.Namespace("http://w3id.org/nfdi4ing/metadata4ing#")
 
 # Create a new HDF5 file with FAIR metadata
 with h5tbx.File("example.h5", "w") as h5:
-    h5.create_dataset("temperature", data=np.array([20, 21, 19, 22]))
-    h5.attrs["units", M4I.hasUnit] = "degree_Celsius"
-    h5.rdf["units"].object = "http://qudt.org/vocab/unit/DEG_C"
-    h5.attrs["description", "https://schema.org/description"] = "Room temperature measurements"
+    ds = h5.create_dataset("temperature", data=np.array([20, 21, 19, 22]))
+    ds.attrs["units"] = h5tbx.Attribute(
+        value="degree_Celsius",
+        rdf_predicate=M4I.hasUnit,
+        rdf_object="http://qudt.org/vocab/unit/DEG_C",
+    )
+    ds.attrs["description", "https://schema.org/description"] = "Room temperature measurements"
+
+    ds_mean = h5.create_dataset("mean_temperature", data=np.mean(h5["temperature"][()]))
+    ds_mean.attrs["units", M4I.hasUnit] = "degree_Celsius"
+    ds_mean.rdf["units"].object = "http://qudt.org/vocab/unit/DEG_C"
+    ds_mean.attrs["description", "https://schema.org/description"] = "Mean room temperature measurements"
+
+    ds_mean.rdf.type = M4I.NumericalVariable
+    ds_mean.rdf.data_predicate = M4I.hasNumericalValue
+
+    ttl_ctx = h5.serialize("ttl", structural=False, contextual=True, file_uri="https://example.org#example.h5/")
+    ttl_struc = h5.serialize("ttl", structural=True, contextual=False, file_uri="https://example.org#example.h5/")
+    ttl_full = h5.serialize("ttl", file_uri="https://example.org#example.h5/")
+```
 
-    ttl = h5.serialize("ttl")
+The above saves three different serializations of the HDF5 content as RDF in Turtle (ttl) format.
+The first one (`ttl_ctx`) is the **contextual** RDF serialization, which only includes the RDF triples that the user
+has enriched the HDF5 file with. The second one (`ttl_struc`) is the **structural** RDF serialization, which includes 
+all RDF triples that can be derived from the HDF5 file content. the third one (`ttl_full`) is the combination of the 
+first two, which includes both the user enriched RDF triples and the RDF triples that can be derived from the HDF5 file 
+content.
 
-```
-The serialization in Turtle (ttl) is teh RDF serialization of the HDF5 data (without arrays):
+Below we show the first two serializations.
+
+`ttl_ctx`:
 ```ttl
-@prefix hdf: <http://purl.allotrope.org/ontologies/hdf5/1.8#> .
 @prefix m4i: <http://w3id.org/nfdi4ing/metadata4ing#> .
 @prefix schema: <https://schema.org/> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
+<https://example.org#example.h5/example.h5/mean_temperature> a m4i:NumericalVariable ;
+    m4i:hasNumericalValue "20.5"^^xsd:float ;
+    m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
+    schema:description "Mean room temperature measurements" .
+
+<https://example.org#example.h5/example.h5/temperature> m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
+    schema:description "Room temperature measurements" .
+```
+
+`ttl_ctx`:
+```ttl
+@prefix hdf: <http://purl.allotrope.org/ontologies/hdf5/1.8#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+<https://example.org#example.h5/example.h5> a hdf:File ;
+    hdf:rootGroup <https://example.org#example.h5/example.h5/> .
+
+hdf:H5T_IEEE_F64LE a hdf:Datatype .
+
 hdf:H5T_INTEL_I64 a hdf:Datatype .
 
-[] a hdf:File ;
-    hdf:rootGroup [ a hdf:Group ;
-            hdf:attribute [ a hdf:StringAttribute ;
-                    hdf:data "Room temperature measurements" ;
-                    hdf:name "description" ],
-                [ a hdf:StringAttribute ;
-                    hdf:data "degree_Celsius" ;
-                    hdf:name "units" ] ;
-            hdf:member [ a hdf:Dataset ;
-                    hdf:dataspace [ a hdf:SimpleDataspace ;
-                            hdf:dimension [ a hdf:DataspaceDimension ;
-                                    hdf:dimensionIndex 0 ;
-                                    hdf:size 4 ] ] ;
-                    hdf:datatype hdf:H5T_INTEGER,
-                        hdf:H5T_INTEL_I64 ;
-                    hdf:layout hdf:H5D_CONTIGUOUS ;
-                    hdf:maximumSize 4 ;
-                    hdf:name "/temperature" ;
-                    hdf:rank 1 ;
-                    hdf:size 4 ] ;
-            hdf:name "/" ;
-            m4i:hasUnit <http://qudt.org/vocab/unit/DEG_C> ;
-            schema:description "Room temperature measurements" ] .
+<https://example.org#example.h5/example.h5/> a hdf:Group ;
+    hdf:member <https://example.org#example.h5/example.h5/mean_temperature>,
+        <https://example.org#example.h5/example.h5/temperature> ;
+    hdf:name "/" .
+
+<https://example.org#example.h5/example.h5/mean_temperature> a hdf:Dataset ;
+    hdf:attribute <https://example.org#example.h5/example.h5/mean_temperature@description>,
+        <https://example.org#example.h5/example.h5/mean_temperature@units> ;
+    hdf:dataspace <https://example.org#example.h5/example.h5/mean_temperature__dataspace> ;
+    hdf:datatype hdf:H5T_FLOAT,
+        hdf:H5T_IEEE_F64LE ;
+    hdf:layout hdf:H5D_CONTIGUOUS ;
+    hdf:maximumSize -1 ;
+    hdf:name "/mean_temperature" ;
+    hdf:rank 0 ;
+    hdf:size 1 ;
+    hdf:value 2.05e+01 .
+
+<https://example.org#example.h5/example.h5/mean_temperature@description> a hdf:StringAttribute ;
+    hdf:data "Mean room temperature measurements" ;
+    hdf:name "description" .
+
+<https://example.org#example.h5/example.h5/mean_temperature@units> a hdf:StringAttribute ;
+    hdf:data "degree_Celsius" ;
+    hdf:name "units" .
+
+<https://example.org#example.h5/example.h5/mean_temperature__dataspace> a hdf:ScalarDataspace .
+
+<https://example.org#example.h5/example.h5/temperature> a hdf:Dataset ;
+    hdf:attribute <https://example.org#example.h5/example.h5/temperature@description>,
+        <https://example.org#example.h5/example.h5/temperature@units> ;
+    hdf:dataspace <https://example.org#example.h5/example.h5/temperature__dataspace> ;
+    hdf:datatype hdf:H5T_INTEGER,
+        hdf:H5T_INTEL_I64 ;
+    hdf:layout hdf:H5D_CONTIGUOUS ;
+    hdf:maximumSize 4 ;
+    hdf:name "/temperature" ;
+    hdf:rank 1 ;
+    hdf:size 4 .
+
+<https://example.org#example.h5/example.h5/temperature@description> a hdf:StringAttribute ;
+    hdf:data "Room temperature measurements" ;
+    hdf:name "description" .
+
+<https://example.org#example.h5/example.h5/temperature@units> a hdf:StringAttribute ;
+    hdf:data "degree_Celsius" ;
+    hdf:name "units" .
+
+<https://example.org#example.h5/example.h5/temperature__dataspace> a hdf:SimpleDataspace ;
+    hdf:dimension <https://example.org#example.h5/example.h5/temperature__dataspace_dimension_0> .
+
+<https://example.org#example.h5/example.h5/temperature__dataspace_dimension_0> a hdf:DataspaceDimension ;
+    hdf:dimensionIndex 0 ;
+    hdf:size 4 .
 ```
 
 [//]: # (The "HDF5 Research Data Management Toolbox" &#40;h5RDMtoolbox&#41; is a Python package supporting everybody who is working with)

{h5rdmtoolbox-2.7.1 → h5rdmtoolbox-2.7.3}/h5rdmtoolbox/__init__.py

@@ -282,7 +282,7 @@ def serialize(hdf_filename,
               skipND: int = 1,
               structural: bool = True,
               contextual: bool = True,
-              file_uri: Optional[str] = None,
+              file_uri: Optional[Union[str, Dict[str, str]]] = None,
               rdf_mappings: Dict[str, RDFMappingEntry] = None,
               **kwargs):
     """Alternative to json-ld but allows multiple serialization options"""

{h5rdmtoolbox-2.7.1 → h5rdmtoolbox-2.7.3}/h5rdmtoolbox/ld/rdf.py

@@ -363,6 +363,12 @@ class _RDFPO(abc.ABC):
     def __iter__(self):
         return iter(self.keys())
 
+class RDF_Data_Predicate(_RDFPO):
+    """IRI dataset data attribute manager for predicates"""
+    IRI_ATTR_NAME = RDF_PREDICATE_ATTR_NAME
+
+    def __setiri__(self, key, value):
+        set_predicate(self._attr, key, value, rdf_predicate_attr_name=RDF_FILE_PREDICATE_ATTR_NAME)
 
 class RDF_Predicate(_RDFPO):
     """IRI class attribute manager"""
@@ -397,6 +403,7 @@ class RDFManager:
         if key not in ('_attr',
                        'subject',
                        'predicate',
+                       'data_predicate',
                        'file_predicate',
                        'type'):
             raise KeyError(f"Cannot set {key}. Only subject, predicate and type can be set!")
@@ -588,6 +595,25 @@ class RDFManager:
         else:
             self._attr[RDF_TYPE_ATTR_NAME] = iri_type_data
 
+
+    @property
+    def data_predicate(self) -> RDF_Data_Predicate:
+        """Return the RDF predicate manager"""
+        return RDF_Data_Predicate(self._attr)
+
+    @data_predicate.setter
+    def data_predicate(self, data_predicate) -> RDF_Predicate:
+        """Sets the predicate associated with the dataset data. This is useful for JSON-LD export, where the dataset data is represented as a value of a predicate."""
+        if not isinstance(data_predicate, str):
+            raise TypeError(f'Expecting a string or URL. Got {type(data_predicate)}. Note, that a predicate of '
+                            'a group or dataset can only be one value. If you meant to set one or multiple RDF types, '
+                            'use .type instead.')
+        iri_predicate_data = self._attr.get(RDF_PREDICATE_ATTR_NAME, None)
+        if iri_predicate_data is None:
+            iri_predicate_data = {}
+        iri_predicate_data.update({'DATA_PREDICATE': data_predicate})
+        self._attr[RDF_PREDICATE_ATTR_NAME] = iri_predicate_data
+
     @property
     def predicate(self) -> RDF_Predicate:
         """Return the RDF predicate manager"""

{h5rdmtoolbox-2.7.1 → h5rdmtoolbox-2.7.3}/h5rdmtoolbox/ld/user/attributes.py

@@ -155,11 +155,15 @@ def process_attribute(parent_obj, name, data, graph, blank_node_iri_base):
     rdf_manager = RDFManager(parent_obj.attrs)
 
     parent_uri = rdf_manager.subject
+    rdf_user_type = rdf_manager.type
     if parent_uri:
         parent_uri = to_uriref(parent_uri, blank_node_iri_base)
     else:
+        # if rdf_user_type:
+        #     parent_uri = get_obj_bnode(parent_obj, blank_node_iri_base=blank_node_iri_base)
+        # else:
         parent_uri = get_obj_bnode(parent_obj, blank_node_iri_base)
-    rdf_user_type = rdf_manager.type
+
     if rdf_user_type is not None:
         if isinstance(rdf_user_type, (list, np.ndarray)):
             for t in rdf_user_type:

h5rdmtoolbox-2.7.3/h5rdmtoolbox/ld/user/datasets.py

@@ -0,0 +1,76 @@
+import json
+import warnings
+
+import numpy as np
+import rdflib
+from ontolutils.namespacelib import SCHEMA
+
+from h5rdmtoolbox.ld.rdf import PROTECTED_ATTRIBUTE_NAMES
+from h5rdmtoolbox.ld.user.attributes import process_attribute
+from h5rdmtoolbox.ld.utils import get_obj_bnode, to_literal
+from .utils import apply_rdf_mappings, to_uriref
+from ..rdf import RDFManager
+
+
+def process_dataset(*, dataset, graph, rdf_mappings, blank_node_iri_base=None):
+    dataset_uri = get_obj_bnode(dataset, blank_node_iri_base=blank_node_iri_base)
+    for ak, av in dataset.attrs.items():
+        if ak not in PROTECTED_ATTRIBUTE_NAMES:
+            process_attribute(dataset, ak, av, graph, blank_node_iri_base=blank_node_iri_base)
+    apply_rdf_mappings(dataset, dataset_uri, graph, rdf_mappings)
+
+    rdf_manager = RDFManager(dataset.attrs)
+    rdf_type = rdf_manager.type
+    if rdf_type is not None:
+        if isinstance(rdf_type, (list, np.ndarray)):
+            for t in rdf_type:
+                graph.add((dataset_uri, rdflib.RDF.type, rdflib.URIRef(t)))
+        else:
+            graph.add((dataset_uri, rdflib.RDF.type, rdflib.URIRef(rdf_type)))
+
+    rdf_subject = rdf_manager.subject
+    if rdf_subject:
+        if dataset_uri != rdflib.URIRef(rdf_subject):
+            graph.add((dataset_uri, SCHEMA.about, rdflib.URIRef(rdf_subject)))
+
+    rdf_predicate = rdf_manager.predicate
+    if rdf_predicate:
+        _predicates = dataset.attrs.get("RDF_PREDICATE", None)
+        if _predicates:
+            _predicate_dict = json.loads(_predicates)
+            self_predicate = _predicate_dict.get("SELF", None)
+            data_predicate = _predicate_dict.get("DATA_PREDICATE", None)
+
+            if data_predicate:
+                if dataset.ndim > 0:
+                    warnings.warn(f"DATA_PREDICATE is not applicable to datasets with more than 0 dimensions. Ignoring DATA_PREDICATE for dataset {dataset.name}")
+                graph.add((dataset_uri, to_uriref(data_predicate, blank_node_iri_base), to_literal(dataset[()])))
+
+            if self_predicate:
+                parent_uri = get_obj_bnode(dataset.parent, blank_node_iri_base=blank_node_iri_base)
+
+                _parent_subject = RDFManager(dataset.parent.attrs).subject
+
+                if _parent_subject:
+                    if rdf_subject:
+                        graph.add(
+                            (rdflib.URIRef(_parent_subject), rdflib.URIRef(self_predicate), rdflib.URIRef(rdf_subject)))
+                    else:
+                        graph.add((rdflib.URIRef(_parent_subject), rdflib.URIRef(self_predicate), dataset_uri))
+                else:
+                    if rdf_subject:
+                        graph.add((parent_uri, rdflib.URIRef(self_predicate), rdflib.URIRef(rdf_subject)))
+                    else:
+                        parent_rdf_manager = RDFManager(dataset.parent.attrs)
+                        _parent_type = parent_rdf_manager.type
+                        if _parent_type:
+                            _parent_subject_alternative = get_obj_bnode(dataset.parent, blank_node_iri_base=blank_node_iri_base)
+
+                            dataset_uri_alternative = get_obj_bnode(dataset, blank_node_iri_base=blank_node_iri_base)
+                            graph.add((_parent_subject_alternative,
+                                       rdflib.URIRef(self_predicate),
+                                       dataset_uri_alternative))
+                            # graph.add((_parent_subject_alternative, rdflib.URIRef(self_predicate),
+                            #            dataset_uri))
+                        else:
+                            graph.add((parent_uri, rdflib.URIRef(self_predicate), dataset_uri))

h5rdmtoolbox-2.7.3/h5rdmtoolbox/ld/user/groups.py

@@ -0,0 +1,113 @@
+from typing import Optional
+
+import h5py
+import numpy as np
+import rdflib
+from ontolutils.namespacelib import SCHEMA
+
+from h5rdmtoolbox.ld.rdf import PROTECTED_ATTRIBUTE_NAMES
+from h5rdmtoolbox.ld.user.attributes import process_attribute
+from h5rdmtoolbox.ld.user.datasets import process_dataset
+from h5rdmtoolbox.ld.utils import get_obj_bnode, get_file_bnode
+from .utils import apply_rdf_mappings, to_uriref
+from ..rdf import RDFManager
+
+
+def process_group(*, group, graph, rdf_mappings, blank_node_iri_base: Optional[str] = None):
+    group_uri = get_obj_bnode(group, blank_node_iri_base)
+
+    for ak, av in group.attrs.items():
+        if ak not in PROTECTED_ATTRIBUTE_NAMES:
+            process_attribute(group, ak, av, graph, blank_node_iri_base)
+    apply_rdf_mappings(group, group_uri, graph, rdf_mappings)
+
+    rdf_manager = RDFManager(group.attrs)
+
+    parent_rdf_manager = RDFManager(group.parent.attrs) if group.parent is not None else None
+    rdf_type = rdf_manager.type
+    rdf_subject = rdf_manager.subject
+
+    # if rdf_predicate:
+    #     _predicates = group.attrs.get("RDF_PREDICATE", None)
+    #     if _predicates:
+    #         self_predicate = json.loads(_predicates).get("SELF", None)
+    #         if self_predicate:
+    #             parent_uri = get_obj_bnode(group.parent, blank_node_iri_base=blank_node_iri_base)
+    #             _parent_subject = RDFManager(group.parent.attrs).subject
+    #
+    #             if _parent_subject:
+    #                 if rdf_subject:
+    #                     graph.add((rdflib.URIRef(_parent_subject), rdflib.URIRef(self_predicate), rdflib.URIRef(rdf_subject)))
+    #                 else:
+    #                     graph.add((rdflib.URIRef(_parent_subject), rdflib.URIRef(self_predicate), group_uri))
+    #             else:
+    #                 if rdf_subject:
+    #                     graph.add((parent_uri, rdflib.URIRef(self_predicate), rdflib.URIRef(rdf_subject)))
+    #                 else:
+    #                     graph.add((parent_uri, rdflib.URIRef(self_predicate), group_uri))
+
+    if rdf_type is not None and not rdf_subject:
+        rdf_subject = get_obj_bnode(group, blank_node_iri_base=blank_node_iri_base)
+
+    if rdf_type is not None:
+        if rdf_subject:
+            if isinstance(rdf_type, (list, np.ndarray)):
+                for t in rdf_type:
+                    graph.add((to_uriref(rdf_subject, blank_node_iri_base), rdflib.RDF.type, to_uriref(t, blank_node_iri_base)))
+            else:
+                graph.add((to_uriref(rdf_subject, blank_node_iri_base), rdflib.RDF.type, to_uriref(rdf_type, blank_node_iri_base)))
+        else:
+            if isinstance(rdf_type, (list, np.ndarray)):
+                for t in rdf_type:
+                    graph.add((group_uri, rdflib.RDF.type, to_uriref(t, blank_node_iri_base)))
+            else:
+                graph.add((group_uri, rdflib.RDF.type, to_uriref(rdf_type, blank_node_iri_base)))
+
+    if rdf_subject:
+        rdf_subject = to_uriref(rdf_subject, blank_node_iri_base)
+        if group_uri != rdf_subject:
+            graph.add((group_uri, SCHEMA.about, rdf_subject))
+        rdf_predicate = rdf_manager.predicate
+        if rdf_predicate.get("SELF", None):
+            # graph.add((group_uri, rdflib.URIRef(rdf_predicate["SELF"]), rdf_subject))
+            if parent_rdf_manager.subject is not None:
+                _parent_subject = to_uriref(parent_rdf_manager.subject)
+            else:
+                _parent_type = parent_rdf_manager.type
+                # if _parent_type is None:
+                #     _parent_subject = None
+                # else:
+                _parent_subject = get_obj_bnode(group.parent, blank_node_iri_base=blank_node_iri_base)
+            if _parent_subject is not None:
+                graph.add(
+                    (
+                        _parent_subject,
+                        rdflib.URIRef(rdf_predicate["SELF"]),
+                        rdf_subject
+                    )
+                )
+
+        rdf_file_predicate = rdf_manager.file_predicate
+        if rdf_file_predicate is not None:
+            file_uri = get_file_bnode(group.file, blank_node_iri_base)
+            graph.add(
+                (
+                    file_uri,
+                    rdflib.URIRef(rdf_file_predicate),
+                    rdf_subject
+                )
+            )
+
+    # Iterate through items in the group
+    for name, sub_group_or_dataset in group.items():
+
+        # sub_group_or_dataset_uri = rdflib.BNode(sub_group_or_dataset.id.id)
+        # graph.add((group_uri, HDF.member, sub_group_or_dataset_uri))
+
+        if isinstance(sub_group_or_dataset, h5py.Group):
+            process_group(group=sub_group_or_dataset, graph=graph, rdf_mappings=rdf_mappings,
+                          blank_node_iri_base=blank_node_iri_base)
+
+        elif isinstance(sub_group_or_dataset, h5py.Dataset):
+            process_dataset(dataset=sub_group_or_dataset, graph=graph, rdf_mappings=rdf_mappings,
+                            blank_node_iri_base=blank_node_iri_base)

h5rdmtoolbox-2.7.3/h5rdmtoolbox/ld/user/utils.py

@@ -0,0 +1,53 @@
+import hashlib
+from typing import Union
+
+import rdflib
+
+from h5rdmtoolbox.ld.rdf import PROTECTED_ATTRIBUTE_NAMES
+from ..utils import to_literal
+
+
+# def get_obj_bnode(s: str, bits: int = 64, blank_node_iri_base=None) -> rdflib.URIRef:
+#     """Create a deterministic blank node from a string."""
+#     digest = hashlib.sha256(s.encode("utf-8")).digest()
+#     number = int.from_bytes(digest[:bits // 8], "big")
+#     return to_uriref(f"_:{str(number)}", blank_node_iri_base)
+
+
+def to_uriref(value: str, blank_node_iri_base: str = None) -> Union[rdflib.URIRef, rdflib.BNode]:
+    """Convert a value to a URIRef, handling blank nodes if necessary."""
+    if isinstance(value, rdflib.BNode):
+        if blank_node_iri_base is not None:
+            return rdflib.URIRef(blank_node_iri_base + str(value))
+        return value
+    if isinstance(value, rdflib.URIRef):
+        return value
+    if value.startswith("_:"):
+        if blank_node_iri_base is not None:
+            value = blank_node_iri_base + value[2:]
+            return rdflib.URIRef(value)
+        return rdflib.BNode(value[2:])
+    if value.startswith("http://") or value.startswith("https://") or value.startswith("urn:"):
+        return rdflib.URIRef(value)
+    raise ValueError(f"Cannot convert value '{value}' to URIRef")
+
+
+def apply_rdf_mappings(obj, obj_uri, graph, rdf_mappings):
+    for ak, av in obj.attrs.items():
+        if ak not in PROTECTED_ATTRIBUTE_NAMES:
+            if ak in rdf_mappings:
+                mapping = rdf_mappings[ak]
+                predicate_uri = rdflib.URIRef(mapping['predicate'])
+                if predicate_uri:
+                    object_uri = mapping.get('object')
+                    if object_uri:
+                        if callable(object_uri):
+                            object_uri = str(object_uri(av, obj.attrs))
+                            if object_uri is None:
+                                return
+                        graph.add((obj_uri, predicate_uri, rdflib.URIRef(object_uri)))
+                    else:
+                        graph.add((obj_uri, predicate_uri, to_literal(av)))
+                type_uri = mapping.get('type')
+                if type_uri:
+                    graph.add((obj_uri, rdflib.RDF.type, rdflib.URIRef(type_uri)))