h5rdmtoolbox 2.6.2__tar.gz → 2.7.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h5rdmtoolbox
-Version: 2.6.2
+Version: 2.7.1
 Summary: Supporting a FAIR Research Data lifecycle using Python and HDF5.
 Author-email: Matthias Probst <matth.probst@gmail.com>
 License-Expression: MIT

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

@@ -55,6 +55,7 @@ import json
 from .wrapper.accessor import register_accessor
 
 from .ld.shacl import validate_hdf, ValidationResult
+from .ld._types import RDFMappingEntry
 # noinspection PyUnresolvedReferences
 from .utils import DownloadFileManager
 
@@ -282,6 +283,7 @@ def serialize(hdf_filename,
               structural: bool = True,
               contextual: bool = True,
               file_uri: Optional[str] = None,
+              rdf_mappings: Dict[str, RDFMappingEntry] = None,
               **kwargs):
     """Alternative to json-ld but allows multiple serialization options"""
     fmt = kwargs.pop("format", fmt)
@@ -290,7 +292,8 @@ def serialize(hdf_filename,
                             skipND=skipND,
                             structural=structural,
                             contextual=contextual,
-                            file_uri=file_uri)
+                            file_uri=file_uri,
+                            rdf_mappings=rdf_mappings)
 
 
 def build_pyvis_graph(hdf_filename, output_filename="kg-graph.html", notebook=False,

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/catalog/abstracts.py

@@ -80,7 +80,8 @@ class DataStore(Store, ABC):
 class MetadataStore(Store, ABC):
     """Metadata database interface using."""
 
-    __populate_on_init__ = False
+    __supports_named_graphs__: bool
+    __populate_on_init__: bool = False
     __shacl_shapes__: Dict[str, rdflib.Graph] = {}
 
     @abstractmethod

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/catalog/core.py

@@ -121,6 +121,8 @@ class RemoteSparqlStore(MetadataStore):
 
 class GraphDB(RemoteSparqlStore):
     """GraphDB RDF database store."""
+
+    __supports_named_graphs__: bool=True
     __supported_file_extensions__ = {".ttl", ".rdf", ".jsonld"}
 
     def __init__(self,
@@ -401,7 +403,7 @@ class GraphDB(RemoteSparqlStore):
 
 class InMemoryRDFStore(RDFStore):
     """In-memory RDF database that can upload files and return a combined graph."""
-
+    __supports_named_graphs__=False
     __default_expected_file_extensions__ = {".ttl", ".rdf", ".jsonld", ".nt", ".xml", ".n3"}
     __populate_on_init__ = True
 
@@ -786,6 +788,10 @@ class HDF5SqlDB(DataStore):
 class MetadataStoreQuery(Query, ABC):
     """RDF Store Query interface."""
 
+    @abstractmethod
+    def execute(self, store: "Store", named_graph: Optional[str]=None) -> "QueryResult":
+        """Executes the query against the given metadata store with optional named graph."""
+
 
 class SparqlQuery(MetadataStoreQuery):
     """A SPARQL query interface for RDF stores."""

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/ld/__init__.py

@@ -4,18 +4,21 @@ from typing import Union, Optional, Dict
 import h5py
 import rdflib
 
+from ._types import RDFMappingEntry
 from .hdf.file import get_ld as get_hdf_ld
 from .user.file import get_ld as get_contextual_ld
 from .utils import optimize_context
 
-
+BINARY_AS_STRING=True
 def get_ld(
         hdf_filename: Union[str, pathlib.Path],
         structural: bool = True,
         contextual: bool = True,
         file_uri: Optional[str] = None,
         skipND: Optional[int] = 1,
-        context: Optional[Dict] = None) -> rdflib.Graph:
+        context: Optional[Dict] = None,
+        rdf_mappings: Dict[str, RDFMappingEntry] = None
+) -> rdflib.Graph:
     """Return the HDF file content as a rdflib.Graph object."""
     if file_uri and not (str(file_uri).endswith("#") or str(file_uri).endswith("/")):
         raise ValueError("file_uri must end with '#' or '/'")
@@ -23,7 +26,8 @@ def get_ld(
     with h5py.File(hdf_filename) as h5:
         if contextual and structural:
             graph1 = get_hdf_ld(h5, file_uri=file_uri, skipND=skipND)
-            graph2 = get_contextual_ld(h5, file_uri=file_uri)
+            graph2 = get_contextual_ld(h5, file_uri=file_uri,
+                                       rdf_mappings=rdf_mappings)
             graph = graph1 + graph2
         else:
             if structural:

h5rdmtoolbox-2.7.1/h5rdmtoolbox/ld/_types.py

@@ -0,0 +1,11 @@
+from typing import Callable, Optional, Any
+
+from pydantic import BaseModel, Field
+
+
+class RDFMappingEntry(BaseModel):
+    predicate: Optional[Any] = Field(None, description="Predicate IRI or rdflib term")
+    object: Optional[Callable[[Any], Any]] = Field(None, description="Function to generate object value")
+
+    class Config:
+        arbitrary_types_allowed = True

h5rdmtoolbox-2.7.1/h5rdmtoolbox/ld/hdf/attributes.py

@@ -0,0 +1,57 @@
+import warnings
+
+import numpy as np
+from ontolutils.namespacelib.hdf5 import HDF5
+from rdflib import Namespace, Literal, XSD, RDF
+
+from ..utils import get_attr_node, to_literal
+
+HDF = Namespace(str(HDF5))
+
+
+def process_attribute(*, name, value, graph, parent, parent_uri, blank_node_iri_base):
+    """Process an HDF5 attribute, adding it to the RDF graph."""
+    if name.isupper() or name.startswith('@'):
+        return
+    attr_uri = get_attr_node(
+        parent,
+        name,
+        blank_node_iri_base
+    )
+
+    if isinstance(value, str):
+        graph.add((attr_uri, RDF.type, HDF5.StringAttribute))
+        if isinstance(value, bytes):
+            value = value.decode('utf-8', errors='ignore')
+        graph.add((attr_uri, HDF.data, to_literal(value)))
+    elif isinstance(value, int):
+        graph.add((attr_uri, RDF.type, HDF5.IntegerAttribute))
+        graph.add((attr_uri, HDF.data, Literal(value, datatype=XSD.integer)))
+    elif isinstance(value, float):
+        graph.add((attr_uri, RDF.type, HDF5.FloatAttribute))
+        graph.add((attr_uri, HDF.data, Literal(value, datatype=XSD.float)))
+    elif isinstance(value, np.ndarray):
+        if value.ndim == 1:
+            for v in value:
+                graph.add((attr_uri, HDF.data, to_literal(v)))
+            if value.dtype.kind in {'i', 'u'}:
+                graph.add((attr_uri, RDF.type, HDF5.IntegerAttribute))
+            elif value.dtype.kind == 'f':
+                graph.add((attr_uri, RDF.type, HDF5.FloatAttribute))
+            else:
+                graph.add((attr_uri, RDF.type, HDF5.Attribute))
+        else:
+            warnings.warn(f"Attribute data containing more than one dimension is not fully supported.")
+            graph.add((attr_uri, RDF.type, HDF5.Attribute))
+            graph.add((attr_uri, HDF.data, to_literal(value)))
+    else:
+        # attributes that are string bytes should be HDF5.StringAttribute
+        if isinstance(value, bytes):
+            value = value.decode('utf-8', errors='ignore')
+            graph.add((attr_uri, RDF.type, HDF5.StringAttribute))
+        else:
+            graph.add((attr_uri, RDF.type, HDF5.Attribute))
+        graph.add((attr_uri, HDF.data, to_literal(value)))
+
+    graph.add((attr_uri, HDF.name, Literal(name)))
+    graph.add((parent_uri, HDF.attribute, attr_uri))

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

@@ -9,7 +9,7 @@ from ontolutils import SCHEMA
 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 h5rdmtoolbox.ld.utils import get_attr_dtype_as_xsd, get_obj_bnode, to_literal
 from .utils import to_uriref
 from ..rdf import FileRDFManager, RDFManager
 
@@ -230,9 +230,11 @@ def process_attribute(parent_obj, name, data, graph, blank_node_iri_base):
                 )
             else:
                 graph.add(
-                    (parent_uri,
-                     to_uriref(rdf_user_predicate, blank_node_iri_base),
-                     Literal(data, datatype=get_attr_dtype_as_xsd(data)))
+                    (
+                        parent_uri,
+                        to_uriref(rdf_user_predicate, blank_node_iri_base),
+                        to_literal(data)
+                    )  # Literal(data, datatype=get_attr_dtype_as_xsd(data)))
                 )
         return _graph
 

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/ld/user/datasets.py

@@ -4,14 +4,16 @@ 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
+from .utils import apply_rdf_mappings
 from ..rdf import RDFManager
 
 
-def process_dataset(dataset, graph, blank_node_iri_base=None):
+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_type = RDFManager(dataset.attrs).type
     if rdf_type is not None:

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/ld/user/file.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Dict
 from typing import Union
 
 import h5py
@@ -12,16 +12,21 @@ 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 .._types import RDFMappingEntry
 from ..rdf import FileRDFManager
+from .utils import apply_rdf_mappings
 
 HDF = Namespace(str(HDF5))
 
 
 def get_ld(
         source: Union[str, h5py.File],
-        file_uri: Optional[str] = None) -> rdflib.Graph:
+        file_uri: Optional[str] = None,
+        rdf_mappings: Dict[str, RDFMappingEntry] = None
+) -> rdflib.Graph:
     """Convert an HDF5 file into an RDF graph."""
-
+    if rdf_mappings is None:
+        rdf_mappings = {}
     if not isinstance(source, h5py.File):
         with h5py.File(source) as h5f:
             return get_ld(h5f, file_uri=file_uri)
@@ -53,6 +58,8 @@ def get_ld(
     for ak, av in source.attrs.items():
         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)
+    apply_rdf_mappings(source, file_node, graph, rdf_mappings)
+
+    process_group(group=source, graph=graph, blank_node_iri_base=file_uri, rdf_mappings=rdf_mappings)
 
     return graph

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/ld/user/groups.py

@@ -8,15 +8,18 @@ from ontolutils.namespacelib import SCHEMA
 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
 from .utils import to_uriref
 from ..rdf import RDFManager
 
 
-def process_group(group, graph, blank_node_iri_base: Optional[str] = None):
+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():
         process_attribute(group, ak, av, graph, blank_node_iri_base)
+    apply_rdf_mappings(group, group_uri, graph, rdf_mappings)
 
-    group_uri = get_obj_bnode(group, blank_node_iri_base)
     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
@@ -57,7 +60,9 @@ def process_group(group, graph, blank_node_iri_base: Optional[str] = None):
         # graph.add((group_uri, HDF.member, sub_group_or_dataset_uri))
 
         if isinstance(sub_group_or_dataset, h5py.Group):
-            process_group(sub_group_or_dataset, graph, blank_node_iri_base=blank_node_iri_base)
+            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(sub_group_or_dataset, graph, blank_node_iri_base=blank_node_iri_base)
+            process_dataset(dataset=sub_group_or_dataset, graph=graph, rdf_mappings=rdf_mappings,
+                            blank_node_iri_base=blank_node_iri_base)

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

@@ -0,0 +1,33 @@
+import rdflib
+from rdflib import URIRef
+
+from h5rdmtoolbox.ld.rdf import PROTECTED_ATTRIBUTE_NAMES
+from ..utils import to_literal
+
+
+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)
+
+
+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)))

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/ld/utils.py

@@ -1,3 +1,4 @@
+import base64
 import pathlib
 import urllib.parse
 from typing import Optional
@@ -5,8 +6,28 @@ from typing import Union
 
 import h5py
 import rdflib
+from rdflib import Literal
 from rdflib.namespace import XSD
 
+def to_literal(value, *, binary_as_string=None, encoding="utf-8") -> Literal:
+    """
+    Convert a Python value to an rdflib Literal.
+
+    - str   -> xsd:string
+    - bytes -> xsd:base64Binary (default)
+    - bytes -> xsd:string if binary_as_string=True
+    """
+    if binary_as_string is None:
+        from . import BINARY_AS_STRING
+        binary_as_string = BINARY_AS_STRING
+    if isinstance(value, bytes):
+        if binary_as_string:
+            return Literal(value.decode(encoding))
+        encoded = base64.b64encode(value).decode("ascii")
+        return Literal(encoded, datatype=XSD.base64Binary)
+
+    return Literal(value, datatype=get_attr_dtype_as_xsd(value))
+
 
 def _parse_obj_name(obj_name: str):
     return urllib.parse.quote(obj_name, safe='/')
@@ -111,9 +132,9 @@ def get_property_node(
     """Get a property node for an HDF5 object."""
     _file_id = _get_file_id(obj.file)
     if obj.name == "/":
-        _id = f"{_file_id}@{name}"
+        _id = f"{_file_id}@{_parse_obj_name(name)}"
     else:
-        _id = f"{_file_id}{_parse_obj_name(obj.name)}__{name}"
+        _id = f"{_file_id}{_parse_obj_name(obj.name)}__{_parse_obj_name(name)}"
     if blank_node_iri_base:
         return rdflib.URIRef(f'{blank_node_iri_base}{_id}')
     return rdflib.BNode(_id)
@@ -125,9 +146,9 @@ def get_attr_node(
         blank_node_iri_base: str) -> Union[rdflib.URIRef, rdflib.BNode]:
     _file_id = _get_file_id(obj.file)
     if obj.name == "/":
-        _id = f"{_file_id}@{name}"
+        _id = f"{_file_id}@{_parse_obj_name(name)}"
     else:
-        _id = f"{_file_id}{_parse_obj_name(obj.name)}@{name}"
+        _id = f"{_file_id}{_parse_obj_name(obj.name)}@{_parse_obj_name(name)}"
     if blank_node_iri_base:
         return rdflib.URIRef(f'{blank_node_iri_base}{_id}')
     return rdflib.BNode(f"{_id}")

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/utils.py

@@ -32,7 +32,6 @@ logger = logging.getLogger('h5rdmtoolbox')
 DEFAULT_LOGGING_LEVEL = logging.INFO
 RETRY_STATUS = {429, 500, 502, 503, 504}
 
-
 def get_filesize(filename: Union[str, pathlib.Path]) -> int:
     """Get the size of a file in bytes"""
     return os.path.getsize(filename) * get_ureg().byte
@@ -199,9 +198,9 @@ def generate_temporary_filename(prefix='tmp', suffix: str = '', touch: bool = Fa
     tmp_filename: pathlib.Path
         The generated temporary filename
     """
-    _filename = user.UserDir['tmp'] / f"{prefix}{next(user._filecounter)}{suffix}"
+    _filename =  user.UserDir['tmp'] / f"{prefix}{next(user._filecounter)}{suffix}"
     while _filename.exists():
-        _filename = user.UserDir['tmp'] / f"{prefix}{next(user._filecounter)}{suffix}"
+        _filename =  user.UserDir['tmp'] / f"{prefix}{next(user._filecounter)}{suffix}"
     if touch:
         if _filename.suffix in ('.h5', '.hdf', '.hdf5'):
             with h5py.File(_filename, 'w'):
@@ -225,9 +224,9 @@ def generate_temporary_directory(prefix='tmp') -> pathlib.Path:
     tmp_filename: pathlib.Path
         The generated temporary filename
     """
-    _dir = user.UserDir['tmp'] / f"{prefix}{next(user._dircounter)}"
+    _dir =  user.UserDir['tmp'] / f"{prefix}{next(user._dircounter)}"
     while _dir.exists():
-        _dir = user.UserDir['tmp'] / f"{prefix}{next(user._dircounter)}"
+        _dir =  user.UserDir['tmp'] / f"{prefix}{next(user._dircounter)}"
     _dir.mkdir(parents=True)
     return _dir
 

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox/wrapper/core.py

@@ -32,6 +32,7 @@ from .. import protocols
 from .._repr import H5Repr, H5PY_SPECIAL_ATTRIBUTES
 from ..convention.consts import DefaultValue
 from ..ld import rdf
+from ..ld._types import RDFMappingEntry
 
 logger = logging.getLogger('h5rdmtoolbox')
 
@@ -2486,7 +2487,8 @@ class File(h5py.File, Group):
                   contextual: bool = True,
                   file_uri: Optional[Union[str, Dict]] = None,
                   context: Optional[Dict] = None,
-                  indent: int = 2
+                  indent: int = 2,
+                  rdf_mappings: Dict[str, RDFMappingEntry] = None
                   ):
         """Serialize the file content to a specific format"""
         from h5rdmtoolbox.ld.utils import optimize_context
@@ -2510,7 +2512,8 @@ class File(h5py.File, Group):
                        structural=structural,
                        contextual=contextual,
                        file_uri=file_uri,
-                       skipND=skipND)
+                       skipND=skipND,
+                       rdf_mappings=rdf_mappings)
         if prefix:
             graph.bind(prefix, file_uri)
         context = context or {}

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h5rdmtoolbox
-Version: 2.6.2
+Version: 2.7.1
 Summary: Supporting a FAIR Research Data lifecycle using Python and HDF5.
 Author-email: Matthias Probst <matth.probst@gmail.com>
 License-Expression: MIT

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/h5rdmtoolbox.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ h5rdmtoolbox/gui/src/main.py
 h5rdmtoolbox/layout/__init__.py
 h5rdmtoolbox/layout/core.py
 h5rdmtoolbox/ld/__init__.py
+h5rdmtoolbox/ld/_types.py
 h5rdmtoolbox/ld/globals.py
 h5rdmtoolbox/ld/rdf.py
 h5rdmtoolbox/ld/shacl.py

{h5rdmtoolbox-2.6.2 → h5rdmtoolbox-2.7.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "h5rdmtoolbox"
-version = "2.6.2"
+version = "2.7.1"
 description = "Supporting a FAIR Research Data lifecycle using Python and HDF5."
 readme = "README.md"
 requires-python = ">=3.9, <3.14"

h5rdmtoolbox-2.6.2/h5rdmtoolbox/ld/hdf/attributes.py

@@ -1,33 +0,0 @@
-from ontolutils.namespacelib.hdf5 import HDF5
-from rdflib import Namespace, Literal, XSD, RDF
-
-from ..utils import get_attr_node
-
-HDF = Namespace(str(HDF5))
-
-
-def process_attribute(*, name, value, graph, parent, parent_uri, blank_node_iri_base):
-    """Process an HDF5 attribute, adding it to the RDF graph."""
-    if name.isupper() or name.startswith('@'):
-        return
-    attr_uri = get_attr_node(
-        parent,
-        name,
-        blank_node_iri_base
-    )
-
-    if isinstance(value, str):
-        graph.add((attr_uri, RDF.type, HDF5.StringAttribute))
-        graph.add((attr_uri, HDF.data, Literal(value)))
-    elif isinstance(value, int):
-        graph.add((attr_uri, RDF.type, HDF5.IntegerAttribute))
-        graph.add((attr_uri, HDF.data, Literal(value, datatype=XSD.integer)))
-    elif isinstance(value, float):
-        graph.add((attr_uri, RDF.type, HDF5.FloatAttribute))
-        graph.add((attr_uri, HDF.data, Literal(value, datatype=XSD.float)))
-    else:
-        graph.add((attr_uri, RDF.type, HDF5.Attribute))
-        graph.add((attr_uri, HDF.data, Literal(value)))
-
-    graph.add((attr_uri, HDF.name, Literal(name)))
-    graph.add((parent_uri, HDF.attribute, attr_uri))

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

@@ -1,8 +0,0 @@
-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)