h5rdmtoolbox 2.5.1__tar.gz → 2.5.2__tar.gz

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h5rdmtoolbox
-Version: 2.5.1
+Version: 2.5.2
 Summary: Supporting a FAIR Research Data lifecycle using Python and HDF5.
 Home-page: https://h5rdmtoolbox.readthedocs.io/en/latest/
 Author: Matthias Probst
@@ -29,7 +29,7 @@ Requires-Dist: pint>=0.24.4
 Requires-Dist: pint_xarray<=0.6.0,>=0.2.1
 Requires-Dist: regex>=2020.7.9
 Requires-Dist: packaging>=24.1
-Requires-Dist: ontolutils<1.0.0,>=0.21.1
+Requires-Dist: ontolutils<1.0.0,>=0.22.1
 Requires-Dist: python-forge==18.6.0
 Requires-Dist: requests>=2.32.4
 Requires-Dist: pydantic~=2.8
@@ -54,7 +54,7 @@ Provides-Extra: test
 Requires-Dist: pytest>=8.3.3; extra == "test"
 Requires-Dist: pytest-cov>=5.0.0; extra == "test"
 Requires-Dist: pylint; extra == "test"
-Requires-Dist: ssnolib>=1.5.1.4; extra == "test"
+Requires-Dist: ssnolib<3.0.0,>=2.1.0.2; extra == "test"
 Requires-Dist: mongomock==4.1.2; extra == "test"
 Requires-Dist: xmltodict<=0.13.0; extra == "test"
 Requires-Dist: scipy>=1.10.1; extra == "test"
@@ -76,7 +76,7 @@ Requires-Dist: pymongo<=4.10.1,>=4.2.0; extra == "docs"
 Requires-Dist: pytest>=8.3.3; extra == "docs"
 Requires-Dist: pytest-cov>=5.0.0; extra == "docs"
 Requires-Dist: pylint; extra == "docs"
-Requires-Dist: ssnolib>=1.5.1.4; extra == "docs"
+Requires-Dist: ssnolib<3.0.0,>=2.1.0.2; extra == "docs"
 Requires-Dist: mongomock==4.1.2; extra == "docs"
 Requires-Dist: xmltodict<=0.13.0; extra == "docs"
 Requires-Dist: scipy>=1.10.1; extra == "docs"
@@ -102,7 +102,7 @@ Requires-Dist: PyQt5==5.15.10; extra == "complete"
 Requires-Dist: pytest>=8.3.3; extra == "complete"
 Requires-Dist: pytest-cov>=5.0.0; extra == "complete"
 Requires-Dist: pylint; extra == "complete"
-Requires-Dist: ssnolib>=1.5.1.4; extra == "complete"
+Requires-Dist: ssnolib<3.0.0,>=2.1.0.2; extra == "complete"
 Requires-Dist: mongomock==4.1.2; extra == "complete"
 Requires-Dist: xmltodict<=0.13.0; extra == "complete"
 Requires-Dist: scipy>=1.10.1; extra == "complete"
@@ -120,7 +120,7 @@ Requires-Dist: PyQt5==5.15.10; extra == "complete-with-docs"
 Requires-Dist: pytest>=8.3.3; extra == "complete-with-docs"
 Requires-Dist: pytest-cov>=5.0.0; extra == "complete-with-docs"
 Requires-Dist: pylint; extra == "complete-with-docs"
-Requires-Dist: ssnolib>=1.5.1.4; extra == "complete-with-docs"
+Requires-Dist: ssnolib<3.0.0,>=2.1.0.2; extra == "complete-with-docs"
 Requires-Dist: mongomock==4.1.2; extra == "complete-with-docs"
 Requires-Dist: xmltodict<=0.13.0; extra == "complete-with-docs"
 Requires-Dist: scipy>=1.10.1; extra == "complete-with-docs"
@@ -141,7 +141,7 @@ Requires-Dist: pymongo<=4.10.1,>=4.2.0; extra == "complete-with-docs"
 Requires-Dist: pytest>=8.3.3; extra == "complete-with-docs"
 Requires-Dist: pytest-cov>=5.0.0; extra == "complete-with-docs"
 Requires-Dist: pylint; extra == "complete-with-docs"
-Requires-Dist: ssnolib>=1.5.1.4; extra == "complete-with-docs"
+Requires-Dist: ssnolib<3.0.0,>=2.1.0.2; extra == "complete-with-docs"
 Requires-Dist: mongomock==4.1.2; extra == "complete-with-docs"
 Requires-Dist: xmltodict<=0.13.0; extra == "complete-with-docs"
 Requires-Dist: scipy>=1.10.1; extra == "complete-with-docs"

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/__init__.py

@@ -285,11 +285,6 @@ def serialize(hdf_filename,
               **kwargs):
     """Alternative to json-ld but allows multiple serialization options"""
     fmt = kwargs.pop("format", fmt)
-    if file_uri is None:
-        warnings.warn(
-            "Not providing a file-uri is not good practice because it will generate blank nodes. Consider providing an URI such as the DOI URL for example.",
-            category=UserWarning
-        )
     with File(hdf_filename) as h5:
         return h5.serialize(fmt=fmt,
                             skipND=skipND,

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/convention/core.py

@@ -512,7 +512,7 @@ def _import_convention(convention_name) -> "module":
     try:
         return importlib.import_module(f'{convention_name}')
     except ImportError:
-        print(f"Failed to import module {convention_name}")
+        logger.error(f"Failed to import module {convention_name}. Most likely the created convention file is erroneous.")
 
 
 def _get_convention_from_dir(convention_name: str) -> "Convention":
@@ -523,6 +523,7 @@ def _get_convention_from_dir(convention_name: str) -> "Convention":
     _convention_py_filename = CV_DIR / f'{_convention_name}' / f'{_convention_name}.py'
     if not _convention_py_filename.exists():
         raise ConventionNotFound(f'Convention "{convention_name}" not found.')
+    logger.debug(f"Adding path {_convention_py_filename.parent.absolute()} to system path...")
     sys.path.insert(0, str(_convention_py_filename.parent))
     # import:
     _import_convention(_convention_name)
@@ -611,15 +612,6 @@ def get_registered_conventions() -> Dict:
     """Return dictionary of registered convention"""
     return cfg._registered_conventions
 
-
-# unused:
-# def register_convention(new_convention: Convention) -> None:
-#     """Return dictionary of registered convention"""
-#     if new_convention in cfg._registered_conventions:
-#         raise ValueError(f'Convention "{new_convention}" is already registered')
-#     cfg._registered_conventions[new_convention.name] = new_convention
-
-
 def add_convention(convention: Convention, name=None):
     """Add a convention to the list of registered convention"""
     if not isinstance(convention, Convention):
@@ -689,6 +681,7 @@ def from_file(filename) -> Convention:
 
 def from_yaml(filename: Union[str, pathlib.Path], overwrite: bool = False) -> Convention:
     """Load a convention from a YAML file. See Convention.from_yaml() for details"""
+    logger.debug(f"Reading Convention from yaml file: {filename}")
     return Convention.from_yaml(filename, overwrite=overwrite)
 
 

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/ld/__init__.py

@@ -17,8 +17,8 @@ def get_ld(
         skipND: Optional[int] = 1,
         context: Optional[Dict] = None) -> rdflib.Graph:
     """Return the HDF file content as a rdflib.Graph object."""
-    if file_uri and not (str(file_uri)).endswith("#"):
-        file_uri = f"{file_uri}#"
+    if file_uri and not (str(file_uri).endswith("#") or str(file_uri).endswith("/")):
+        raise ValueError("file_uri must end with '#' or '/'")
     graph = None
     with h5py.File(hdf_filename) as h5:
         if contextual and structural:

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/ld/rdf.py

@@ -76,6 +76,10 @@ def validate_url(url: str) -> str:
         Returns the original string if the URL is valid. Thus, white spaces are not replaced
         by %20.
     """
+    if isinstance(url, rdflib.BNode):
+        return url.n3()
+    if isinstance(url, str) and url.startswith("_:"):
+        return url
     try:
         if not url.startswith("http"):
             if ":" in url:
@@ -113,11 +117,17 @@ def set_predicate(attr: h5py.AttributeManager,
     -------
     None
     """
-    try:
-        HttpUrl(value)
-    except pydantic.ValidationError as e:
-        raise RDFError(f'Invalid IRI: "{value}" for attr name "{attr_name}". '
-                       f'Expecting a valid URL. This was validated with pydantic. Pydantic error: {e}')
+    if isinstance(value, rdflib.BNode):
+        value = value.n3()
+    else:
+        if isinstance(value, str) and value.startswith("_:"):
+            pass
+        else:
+            try:
+                HttpUrl(value)
+            except pydantic.ValidationError as e:
+                raise RDFError(f'Invalid IRI: "{value}" for attr name "{attr_name}". '
+                               f'Expecting a valid URL. This was validated with pydantic. Pydantic error: {e}')
 
     iri_name_data = attr.get(rdf_predicate_attr_name, None)
     if iri_name_data is None:
@@ -152,19 +162,32 @@ def set_object(attr: h5py.AttributeManager,
 
     if isinstance(data, Thing):
         data = data.get_jsonld_dict()
+    elif isinstance(data, rdflib.BNode):
+        data = data.n3()
     elif isinstance(data, rdflib.Literal):
         if data.language is not None and data.datatype is None:
             data = {"lexical_or_value": str(data), "lang": data.language, "$type": "rdflib.term.Literal"}
     elif isinstance(data, dict):
         # assuming it is a JSON-LD dict
+        if "@graph" in data:
+            # if one entry, reduce it to a simpler form:
+            if len(data["@graph"]) == 1:
+                _ctx = data.get("@context", None)
+                _data = data["@graph"][0]
+                data = {"@context": _ctx, **_data} if _ctx is not None else _data
+            else:
+                raise RDFError(f"Cannot set multiple graph entries as object for attribute {attr_name}. ")
         if not "@type" in data:
-            raise RDFError(f"The input data is interpreted as JSON-LD, but no @type is found: {data}")
+            raise RDFError(f"The input data is interpreted as JSON-LD, but no '@type' is found: {data}")
     else:
-        try:
-            data = str(HttpUrl(data))
-        except pydantic.ValidationError as e:
-            raise RDFError(f'Invalid IRI: "{data}" for attr name "{attr_name}". '
-                           f'Expecting a valid URL. This was validated with pydantic. Pydantic error: {e}')
+        if isinstance(data, str) and data.startswith("_:"):
+            pass
+        else:
+            try:
+                data = str(HttpUrl(data))
+            except pydantic.ValidationError as e:
+                raise RDFError(f'Invalid IRI: "{data}" for attr name "{attr_name}". '
+                               f'Expecting a valid URL. This was validated with pydantic. Pydantic error: {e}')
     curr_data = iri_data_data.get(attr_name, None)
     if curr_data is None:
         iri_data_data.update({attr_name: data})
@@ -510,9 +533,9 @@ class RDFManager:
         """Add a rdf type (@type in JSON-LD syntax) to the group or dataset.
         If the subject already exists, it will not be added again."""
         if isinstance(rdf_type, list):
-            data = [validate_url(str(i)) for i in rdf_type]
+            data = [validate_url(i) for i in rdf_type]
         else:
-            data = validate_url(str(rdf_type))
+            data = validate_url(rdf_type)
 
         # get the attribute
         if '@TYPE' in self._attr:
@@ -825,9 +848,9 @@ class FileRDFManager:
     def type(self, rdf_type: Union[str, List[str]]):
         """Add a rdf type (@type in JSON-LD syntax) to the hdf5 file (not the root group!)"""
         if isinstance(rdf_type, list):
-            data = [validate_url(str(i)) for i in rdf_type]
+            data = [validate_url(i) for i in rdf_type]
         else:
-            data = validate_url(str(rdf_type))
+            data = validate_url(rdf_type)
 
         # get the attribute
         iri_sbj_data = self._attr.get(RDF_FILE_TYPE_ATTR_NAME, None)

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/ld/user/attributes.py

@@ -10,6 +10,7 @@ from ontolutils.classes.thing import is_url
 from rdflib import RDF, DCTERMS, XSD, URIRef, Literal, Graph, BNode
 
 from h5rdmtoolbox.ld.utils import get_attr_dtype_as_xsd, get_obj_bnode
+from .utils import to_uriref
 from ..rdf import FileRDFManager, RDFManager
 
 # FALLBACK_PREDICATE = SCHEMA.additionalProperty
@@ -24,8 +25,14 @@ def _is_date_str(value: str):
     # quick check, that first character is a digit
     if not re.match(r"^\d", value):
         return None
+    # reject version-like strings composed only of digits and dots, e.g. "2.5.2"
+    if re.match(r"^\d+(?:\.\d+)+$", value):
+        return None
     try:
         dt = parser.parse(value)
+        # reject implausible years (versions can parse as year 2, etc.)
+        if dt.year < 1000:
+            return None
         # Prüfe, ob nur ein Datum (YYYY-MM-DD) vorliegt
         if re.match(r"^\d{4}-\d{2}-\d{2}$", value):
             return dt.date().isoformat(), XSD.date
@@ -35,14 +42,14 @@ def _is_date_str(value: str):
         return None
 
 
-def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef, BNode]):
+def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef, BNode], blank_node_iri_base):
     rdf_user_type = FileRDFManager(parent_obj.attrs).type
     if rdf_user_type is not None:
         if isinstance(rdf_user_type, (list, np.ndarray)):
             for t in rdf_user_type:
-                graph.add((file_uri, RDF.type, URIRef(t)))
+                graph.add((file_uri, RDF.type, to_uriref(t, blank_node_iri_base)))
         else:
-            graph.add((file_uri, RDF.type, URIRef(rdf_user_type)))
+            graph.add((file_uri, RDF.type, to_uriref(rdf_user_type, blank_node_iri_base)))
     rdf_user_predicate = FileRDFManager(parent_obj.attrs).predicate[name]
 
     rdf_user_object = FileRDFManager(parent_obj.attrs).object[name]
@@ -52,21 +59,22 @@ def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef
             rdf_user_predicate = FALLBACK_PREDICATE_FOR_LITERAL_OBJECTS
         else:
             rdf_user_predicate = FALLBACK_PREDICATE_FOR_IRI_OBJECTS
-        rdf_user_object = SCHEMA.PropertyValue
+        # rdf_user_object = SCHEMA.PropertyValue
 
     if rdf_user_predicate:
         if rdf_user_object:
             if isinstance(rdf_user_object, Literal):
-                graph.add((file_uri, URIRef(rdf_user_predicate), rdf_user_object))
+                graph.add((file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base), rdf_user_object))
             if isinstance(rdf_user_object, str) and rdf_user_object.startswith('http'):
-                graph.add((file_uri, URIRef(rdf_user_predicate), URIRef(rdf_user_object)))
+                graph.add((file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                           to_uriref(rdf_user_object, blank_node_iri_base)))
             elif isinstance(rdf_user_object, list):
                 for ruo in rdf_user_object:
                     if isinstance(ruo, Literal):
-                        graph.add((file_uri, URIRef(rdf_user_predicate), ruo))
+                        graph.add((file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base), ruo))
 
                     elif isinstance(ruo, str) and ruo.startswith('http'):
-                        graph.add((file_uri, URIRef(rdf_user_predicate), URIRef(ruo)))
+                        graph.add((file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base), URIRef(ruo)))
 
                     elif isinstance(ruo, dict):
                         try:
@@ -76,7 +84,9 @@ def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef
                             if len(_subjects) != 1:
                                 warnings.warn(f"Error parsing JSON-LD object for attribute. name={name}, data={data}. "
                                               f"Expected exactly one subject, found {len(_subjects)}")
-                            obj_graph.add((file_uri, URIRef(rdf_user_predicate), list(_subjects)[0]))
+                            obj_graph.add(
+                                (file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                                 to_uriref(list(_subjects)[0], blank_node_iri_base)))
                             graph += obj_graph
                         except Exception as e:
                             warnings.warn(
@@ -90,7 +100,8 @@ def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef
                     if len(_subjects) != 1:
                         warnings.warn(f"Error parsing JSON-LD object for attribute. name={name}, data={data}. "
                                       f"Expected exactly one subject, found {len(_subjects)}")
-                    obj_graph.add((file_uri, URIRef(rdf_user_predicate), list(_subjects)[0]))
+                    obj_graph.add((file_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                                   to_uriref(list(_subjects)[0], blank_node_iri_base)))
                     graph += obj_graph
                 except Exception as e:
                     warnings.warn(
@@ -101,19 +112,19 @@ def process_file_attribute(parent_obj, name, data, graph, file_uri: Union[URIRef
                 date_value, xsd_type = date_info
                 graph.add(
                     (file_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      Literal(date_value, datatype=xsd_type))
                 )
             elif is_url(data):
                 graph.add(
                     (file_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      URIRef(data))
                 )
             else:
                 graph.add(
                     (file_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      Literal(data, datatype=get_attr_dtype_as_xsd(data)))
                 )
     return graph
@@ -124,16 +135,16 @@ def process_attribute(parent_obj, name, data, graph, blank_node_iri_base):
 
     parent_uri = rdf_manager.subject
     if parent_uri:
-        parent_uri = URIRef(parent_uri)
+        parent_uri = to_uriref(parent_uri, 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:
-                graph.add((parent_uri, RDF.type, URIRef(t)))
+                graph.add((parent_uri, RDF.type, to_uriref(t, blank_node_iri_base)))
         else:
-            graph.add((parent_uri, RDF.type, URIRef(rdf_user_type)))
+            graph.add((parent_uri, RDF.type, to_uriref(rdf_user_type, blank_node_iri_base)))
     rdf_user_predicate = rdf_manager.predicate[name]
     rdf_user_object = rdf_manager.object[name]
     if rdf_user_object and not rdf_user_predicate:
@@ -146,23 +157,37 @@ def process_attribute(parent_obj, name, data, graph, blank_node_iri_base):
     def _add_to_graph(_rdf_user_object, _graph):
         if _rdf_user_object:
             if isinstance(_rdf_user_object, Literal):
-                _graph.add((parent_uri, URIRef(rdf_user_predicate), _rdf_user_object))
+                _graph.add((parent_uri, to_uriref(rdf_user_predicate, blank_node_iri_base), _rdf_user_object))
             elif isinstance(_rdf_user_object, str) and _rdf_user_object.startswith('http'):
-                _graph.add((parent_uri, URIRef(rdf_user_predicate), URIRef(_rdf_user_object)))
+                _graph.add((parent_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                            to_uriref(_rdf_user_object, blank_node_iri_base)))
             elif isinstance(_rdf_user_object, list):
                 for _itm in _rdf_user_object:
                     _graph = _add_to_graph(_itm, _graph)
             else:
                 if isinstance(_rdf_user_object, dict):
                     try:
-                        obj_graph = Graph().parse(data=json.loads(json.dumps(_rdf_user_object)),
+                        jsonld_dict = json.loads(json.dumps(_rdf_user_object))
+                        obj_graph = Graph().parse(data=jsonld_dict,
                                                   format="json-ld")
-                        # relate the obj_graph with the predicate:
-                        _subjects = set(obj_graph.subjects())
-                        if len(_subjects) != 1:
-                            warnings.warn(f"Error parsing JSON-LD object for attribute. name={name}, data={data}. "
-                                          f"Expected exactly one subject, found {len(_subjects)}")
-                        obj_graph.add((parent_uri, URIRef(rdf_user_predicate), list(_subjects)[0]))
+
+                        if "@graph" not in jsonld_dict:
+                            use_subject = jsonld_dict.get("@id")
+                            obj_graph.add((parent_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                                           to_uriref(use_subject, blank_node_iri_base)))
+                        else:
+                            _graph_entities = jsonld_dict["@graph"]
+                            if len(_graph_entities) == 1:
+                                use_subject = _graph_entities[0].get("@id")
+                                obj_graph.add((parent_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                                               to_uriref(use_subject, blank_node_iri_base)))
+                            else:
+                                for _entity in _graph_entities:
+                                    if RDF.type in _entity and _entity[RDF.type] == str(SCHEMA.PropertyValue):
+                                        use_subject = _entity.get("@id")
+                                        obj_graph.add((parent_uri, to_uriref(rdf_user_predicate, blank_node_iri_base),
+                                                       to_uriref(use_subject, blank_node_iri_base)))
+
                         _graph += obj_graph
                     except Exception as e:
                         warnings.warn(
@@ -173,19 +198,19 @@ def process_attribute(parent_obj, name, data, graph, blank_node_iri_base):
                 date_value, xsd_type = date_info
                 graph.add(
                     (parent_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      Literal(date_value, datatype=xsd_type))
                 )
             elif is_url(data):
                 graph.add(
                     (parent_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      URIRef(data))
                 )
             else:
                 graph.add(
                     (parent_uri,
-                     URIRef(rdf_user_predicate),
+                     to_uriref(rdf_user_predicate, blank_node_iri_base),
                      Literal(data, datatype=get_attr_dtype_as_xsd(data)))
                 )
         return _graph

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/ld/user/file.py

@@ -10,6 +10,7 @@ from rdflib import Namespace
 from h5rdmtoolbox.ld.user.attributes import process_file_attribute
 from h5rdmtoolbox.ld.user.groups import process_group
 from h5rdmtoolbox.ld.utils import get_file_bnode
+from .utils import to_uriref
 from ..rdf import FileRDFManager
 
 HDF = Namespace(str(HDF5))
@@ -25,14 +26,14 @@ def get_ld(
             return get_ld(h5f, file_uri=file_uri)
 
     graph = Graph()
-    graph.bind("m4i", rdflib.URIRef("http://w3id.org/nfdi4ing/metadata4ing#"))
-    graph.bind("ssno", rdflib.URIRef("https://matthiasprobst.github.io/ssno#"))
-    graph.bind("piv", rdflib.URIRef("https://matthiasprobst.github.io/pivmeta#"))
+    graph.bind("m4i", to_uriref("http://w3id.org/nfdi4ing/metadata4ing#"))
+    graph.bind("ssno", to_uriref("https://matthiasprobst.github.io/ssno#"))
+    graph.bind("piv", to_uriref("https://matthiasprobst.github.io/pivmeta#"))
 
     file_frdf_manager = FileRDFManager(source.attrs)
 
     if file_frdf_manager.subject:
-        file_node = rdflib.URIRef(file_frdf_manager.subject)
+        file_node = to_uriref(file_frdf_manager.subject)
     else:
         file_node = get_file_bnode(source, file_uri=file_uri)
 
@@ -44,12 +45,12 @@ def get_ld(
     if file_rdf:
         if isinstance(file_rdf, list):
             for rdf_type in file_rdf:
-                graph.add((file_node, rdflib.RDF.type, rdflib.URIRef(rdf_type)))
+                graph.add((file_node, rdflib.RDF.type, to_uriref(rdf_type, file_uri)))
         else:
-            graph.add((file_node, rdflib.RDF.type, rdflib.URIRef(file_rdf)))
+            graph.add((file_node, rdflib.RDF.type, to_uriref(file_rdf, file_uri)))
 
     for ak, av in source.attrs.items():
-        process_file_attribute(source, ak, av, graph, file_node)
+        process_file_attribute(source, ak, av, graph, file_node, blank_node_iri_base=file_uri)
 
     process_group(source, graph, blank_node_iri_base=file_uri)
 

{h5rdmtoolbox-2.5.1 → h5rdmtoolbox-2.5.2}/h5rdmtoolbox/ld/user/groups.py

@@ -9,7 +9,7 @@ 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 ..rdf import RDFManager
-
+from .utils import to_uriref
 
 def process_group(group, graph, blank_node_iri_base: Optional[str] = None):
     for ak, av in group.attrs.items():
@@ -22,6 +22,7 @@ def process_group(group, graph, blank_node_iri_base: Optional[str] = None):
 
     # if rdf_type is None:
     if rdf_subject:
+        rdf_subject = to_uriref(rdf_subject, blank_node_iri_base)
         graph.add((group_uri, SCHEMA.about, rdflib.URIRef(rdf_subject)))
         rdf_predicate = rdf_manager.predicate
         if rdf_predicate.get("SELF", None):
@@ -34,15 +35,15 @@ def process_group(group, graph, blank_node_iri_base: Optional[str] = None):
         if rdf_subject:
             if isinstance(rdf_type, (list, np.ndarray)):
                 for t in rdf_type:
-                    graph.add((rdflib.URIRef(rdf_subject), rdflib.RDF.type, rdflib.URIRef(t)))
+                    graph.add((rdflib.URIRef(rdf_subject), rdflib.RDF.type, to_uriref(t, blank_node_iri_base)))
             else:
-                graph.add((rdflib.URIRef(rdf_subject), rdflib.RDF.type, rdflib.URIRef(rdf_type)))
+                graph.add((rdflib.URIRef(rdf_subject), 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, rdflib.URIRef(t)))
+                    graph.add((group_uri, rdflib.RDF.type, to_uriref(t, blank_node_iri_base)))
             else:
-                graph.add((group_uri, rdflib.RDF.type, rdflib.URIRef(rdf_type)))
+                graph.add((group_uri, rdflib.RDF.type, to_uriref(rdf_type, blank_node_iri_base)))
 
     # Iterate through items in the group
     for name, sub_group_or_dataset in group.items():

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

@@ -0,0 +1,8 @@
+from rdflib import URIRef
+
+
+def to_uriref(value: str, blank_node_iri_base: str = None) -> URIRef:
+    """Convert a value to a URIRef, handling blank nodes if necessary."""
+    if value.startswith("_:") and blank_node_iri_base:
+        value = blank_node_iri_base + value[2:]
+    return URIRef(value)