cognite-neat 0.81.4__tar.gz → 0.81.6__tar.gz

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.81.4
+Version: 0.81.6
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.81.6/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.81.6"

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/cognite/neat/graph/extractors/_dexpi.py

@@ -13,6 +13,7 @@ from cognite.neat.utils.utils import as_neat_compliant_uri
 from cognite.neat.utils.xml import get_children, iterate_tree
 
 DEXPI = Namespace("http://sandbox.dexpi.org/rdl/")
+QUDT = Namespace("https://qudt.org/vocab/unit/")
 
 
 class DexpiExtractor(BaseExtractor):
@@ -130,6 +131,11 @@ class DexpiExtractor(BaseExtractor):
         """Converts an XML element to triples."""
         triples: list[Triple] = []
 
+        # setting these to None this is the order of getting the type
+        component_class: str | None = None
+        component_name: str | None = None
+        tag: str | None = None
+
         # adding tag triple if exists
         if tag := element.tag:
             triples.append((id_, DEXPI.tag, Literal(str(tag))))
@@ -140,8 +146,16 @@ class DexpiExtractor(BaseExtractor):
                 triples.append((id_, DEXPI.ComponentClass, Literal(component_class)))
             if component_name := attributes.get("ComponentName", None):
                 triples.append((id_, DEXPI.ComponentName, Literal(component_name)))
-            if type_ := attributes.get("ComponentClassURI", None):
-                triples.append((id_, RDF.type, URIRef(type_)))
+            if component_class_uri := attributes.get("ComponentClassURI", None):
+                triples.append((id_, DEXPI.ComponentClassURI, URIRef(component_class_uri)))
+
+        triples.append(
+            (
+                id_,
+                RDF.type,
+                as_neat_compliant_uri(DEFAULT_NAMESPACE[component_class or component_name or tag or "Unknown"]),
+            )
+        )
 
         # add label triple
         if label := cls._get_element_label(element):
@@ -158,10 +172,17 @@ class DexpiExtractor(BaseExtractor):
         return triples
 
     @classmethod
-    def _value_definition2literal(cls, definition: dict) -> Literal | None:
+    def _value_definition2literal(cls, definition: dict, make_unit_datatype: bool = False) -> Literal | None:
         if "Value" not in definition or "Format" not in definition:
             return None
 
+        if "Units" in definition and "Value" in definition:
+            if make_unit_datatype and "UnitsURI" in definition:
+                return Literal(definition["Value"], datatype=URIRef(definition["UnitsURI"]))
+
+            else:
+                return Literal(definition["Value"], datatype=XSD.float)
+
         # case: when language is present we create add language tag to the literal
         elif "Language" in definition and "Value" in definition:
             return Literal(definition["Value"], lang=definition["Language"])
@@ -202,11 +223,11 @@ class DexpiExtractor(BaseExtractor):
             if grandchildren := get_children(children[0], "GenericAttribute"):
                 for generic_attribute in grandchildren:
                     # extension for schema version 3.3, where "AttributeURI" is not included
-                    if "AttributeURI" in generic_attribute.attrib:
-                        if generic_attribute.attrib["AttributeURI"] not in attributes:
-                            attributes[generic_attribute.attrib["AttributeURI"]] = [generic_attribute.attrib]
-
+                    if name := generic_attribute.attrib.get("Name", None):
+                        attribute_uri = as_neat_compliant_uri(DEFAULT_NAMESPACE[name])
+                        if attribute_uri not in attributes:
+                            attributes[attribute_uri] = [generic_attribute.attrib]
                         else:
-                            attributes[generic_attribute.attrib["AttributeURI"]].append(generic_attribute.attrib)
+                            attributes[attribute_uri].append(generic_attribute.attrib)
 
         return attributes

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/cognite/neat/graph/stores/_base.py

@@ -9,9 +9,11 @@ from rdflib import RDF, Graph, Namespace, URIRef
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 from rdflib.query import ResultRow
 
+from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph._shared import MIMETypes
 from cognite.neat.graph.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat.graph.models import Triple
+from cognite.neat.graph.transformers import Transformers
 from cognite.neat.rules.models.information import InformationRules
 from cognite.neat.utils import remove_namespace
 from cognite.neat.utils.auxiliary import local_import
@@ -56,6 +58,9 @@ class NeatGraphStore:
 
         if self.rules and self.rules.prefixes:
             self._upsert_prefixes(self.rules.prefixes)
+            self.base_namespace = self.rules.metadata.namespace
+        else:
+            self.base_namespace = DEFAULT_NAMESPACE
 
         self.queries = _Queries(self)
 
@@ -206,6 +211,40 @@ class NeatGraphStore:
 
         check_commit(force_commit=True)
 
+    def transform(self, transformer: Transformers) -> None:
+        """Transforms the graph store using a transformer."""
+
+        missing_changes = [
+            change for change in transformer._need_changes if not self.provenance.activity_took_place(change)
+        ]
+        if self.provenance.activity_took_place(type(transformer).__name__) and transformer._use_only_once:
+            warnings.warn(
+                f"Cannot transform graph store with {type(transformer).__name__}, already applied",
+                stacklevel=2,
+            )
+        elif missing_changes:
+            warnings.warn(
+                (
+                    f"Cannot transform graph store with {type(transformer).__name__}, "
+                    f"missing one or more required changes [{', '.join(missing_changes)}]"
+                ),
+                stacklevel=2,
+            )
+
+        else:
+            _start = datetime.now(timezone.utc)
+            transformer.transform(self.graph)
+            self.provenance = Provenance(
+                [
+                    Change.record(
+                        activity=f"{type(transformer).__name__}",
+                        start=_start,
+                        end=datetime.now(timezone.utc),
+                        description=transformer.description,
+                    )
+                ]
+            )
+
 
 class _Queries:
     """Helper class for storing standard queries for the graph store."""

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/cognite/neat/graph/stores/_provenance.py

@@ -89,8 +89,8 @@ class Provenance(UserList[T_Change]):
     def __init__(self, changes: Sequence[T_Change] | None = None):
         super().__init__(changes or [])
 
-    def did_this_happen(self, this: str) -> bool:
-        return any(change.description == this for change in self)
+    def activity_took_place(self, activity: str) -> bool:
+        return any(change.activity.used == activity for change in self)
 
     def __delitem__(self, *args, **kwargs):
         raise TypeError("Cannot delete change from provenance")

cognite_neat-0.81.6/cognite/neat/graph/transformers/__init__.py

@@ -0,0 +1,5 @@
+from ._classic_cdf import AddAssetDepth
+
+__all__ = ["AddAssetDepth"]
+
+Transformers = AddAssetDepth

cognite_neat-0.81.6/cognite/neat/graph/transformers/_base.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import ClassVar
+
+from rdflib import Graph
+
+
+class BaseTransformer(ABC):
+    description: str
+    _use_only_once: bool
+    _need_changes: ClassVar[frozenset[str]] = frozenset()
+
+    @abstractmethod
+    def transform(self, graph: Graph) -> None:
+        raise NotImplementedError()

cognite_neat-0.81.6/cognite/neat/graph/transformers/_classic_cdf.py

@@ -0,0 +1,59 @@
+from typing import cast
+
+from rdflib import Graph, Literal, URIRef
+
+from cognite.neat.constants import DEFAULT_NAMESPACE
+from cognite.neat.graph.extractors import AssetsExtractor
+
+from ._base import BaseTransformer
+
+
+class AddAssetDepth(BaseTransformer):
+    description: str = "Adds depth of asset in the asset hierarchy to the graph"
+    _use_only_once: bool = True
+    _need_changes = frozenset({str(AssetsExtractor.__name__)})
+
+    _parent_template: str = """SELECT ?child ?parent WHERE {{
+                              <{asset_id}> <{parent_prop}> ?child .
+                              OPTIONAL{{?child <{parent_prop}>+ ?parent .}}}}"""
+
+    _root_template: str = """SELECT ?root WHERE {{
+                             <{asset_id}> <{root_prop}> ?root .}}"""
+
+    def __init__(
+        self, asset_type: URIRef | None = None, root_prop: URIRef | None = None, parent_prop: URIRef | None = None
+    ):
+        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
+        self.root_prop = root_prop or DEFAULT_NAMESPACE.root
+        self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parent
+
+    def transform(self, graph: Graph) -> None:
+        """Adds depth of asset in the asset hierarchy to the graph."""
+        for result in graph.query(f"SELECT DISTINCT ?asset_id WHERE {{?asset_id a <{self.asset_type}>}}"):
+            asset_id = cast(tuple, result)[0]
+            if depth := self.get_depth(graph, asset_id, self.root_prop, self.parent_prop):
+                graph.add((asset_id, DEFAULT_NAMESPACE.depth, Literal(depth)))
+
+    @classmethod
+    def get_depth(
+        cls,
+        graph: Graph,
+        asset_id: URIRef,
+        root_prop: URIRef,
+        parent_prop: URIRef,
+    ) -> int | None:
+        """Get asset depth in the asset hierarchy."""
+
+        # Handles non-root assets
+        if res := list(graph.query(cls._parent_template.format(asset_id=asset_id, parent_prop=parent_prop))):
+            return len(cast(list[tuple], res)) + 2 if cast(list[tuple], res)[0][1] else 2
+
+        # Handles root assets
+        elif (
+            (res := list(graph.query(cls._root_template.format(asset_id=asset_id, root_prop=root_prop))))
+            and len(cast(list[tuple], res)) == 1
+            and cast(list[tuple], res)[0][0] == asset_id
+        ):
+            return 1
+        else:
+            return None

cognite_neat-0.81.6/cognite/neat/legacy/graph/extractors/_dexpi.py

@@ -0,0 +1,49 @@
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from rdflib import Namespace
+
+from cognite.neat.constants import PREFIXES
+from cognite.neat.graph.extractors._dexpi import DexpiExtractor
+from cognite.neat.legacy.graph.models import Triple
+
+from ._base import BaseExtractor
+
+_DEXPI_PREFIXES = {
+    "dexpi": Namespace("http://sandbox.dexpi.org/rdl/"),
+    "posccaesar": Namespace("http://data.posccaesar.org/rdl/"),
+}
+
+
+class DexpiXML(BaseExtractor):
+    """
+    DEXPI-XML extractor of RDF triples
+
+    Args:
+        filepath: File path to DEXPI XML file.
+        namespace: Optional custom namespace to use for extracted triples that define data
+                    model instances. Defaults to http://purl.org/cognite/neat/.
+    """
+
+    def __init__(
+        self,
+        filepath: Path | str,
+        base_namespace: str | None = None,
+    ):
+        self.filepath = Path(filepath)
+        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else PREFIXES["neat"]
+
+    def extract(self) -> set[Triple]:
+        """
+        Extracts RDF triples from the graph capturing sheet.
+
+        Returns:
+            List of RDF triples, represented as tuples `(subject, predicate, object)`, that define data model instances
+        """
+        if self.filepath is None:
+            raise ValueError("File path to the graph capturing sheet is not provided!")
+
+        root = ET.parse(self.filepath).getroot()
+
+        # removing legacy code by reusing the maintained version of DexpiExtractor
+        return set(DexpiExtractor(root, self.namespace).extract())

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/cognite/neat/legacy/rules/importers/_graph2rules.py

@@ -134,14 +134,17 @@ def _parse_properties_df(data_model: dict, prefixes: dict, parsing_config: dict
         for property_ in data_model[class_]["properties"]:
             for type_ in data_model[class_]["properties"][property_]["value_type"]:
                 sanitized_property = to_dms_name(property_, "property")
+
+                max_count = max(data_model[class_]["properties"][property_]["occurrence"])
+
                 property_rows.append(
                     [
                         sanitized_class,
                         sanitized_property,
                         None,
-                        type_,
+                        to_dms_name(type_, "value-type"),
                         0,  # setting min count to 0 to be more flexible (all properties are optional)
-                        max(data_model[class_]["properties"][property_]["occurrence"]),
+                        None if max_count > 1 else 1,
                         "rdfpath",
                         f'{data_model[class_]["uri"]}({data_model[class_]["properties"][property_]["uri"]})',
                         str(prefixes[data_model[class_]["properties"][property_]["uri"].split(":")[0]]) + property_,

{cognite_neat-0.81.4 → cognite_neat-0.81.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.81.4"
+version = "0.81.6"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.81.4/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.81.4"

cognite_neat-0.81.4/cognite/neat/legacy/graph/extractors/_dexpi.py

@@ -1,314 +0,0 @@
-import re
-import xml.etree.ElementTree as ET
-from pathlib import Path
-from xml.etree.ElementTree import Element
-
-from rdflib import OWL, RDF, RDFS, SKOS, XSD, Literal, Namespace, URIRef
-
-from cognite.neat.constants import PREFIXES
-from cognite.neat.legacy.graph.models import Triple
-from cognite.neat.legacy.rules.models._base import ALLOWED_PATTERN
-from cognite.neat.utils.utils import get_namespace, remove_namespace
-from cognite.neat.utils.xml import get_children, iterate_tree
-
-from ._base import BaseExtractor
-
-_DEXPI_PREFIXES = {
-    "dexpi": Namespace("http://sandbox.dexpi.org/rdl/"),
-    "posccaesar": Namespace("http://data.posccaesar.org/rdl/"),
-}
-
-
-class DexpiXML(BaseExtractor):
-    """
-    DEXPI-XML extractor of RDF triples
-
-    Args:
-        filepath: File path to DEXPI XML file.
-        namespace: Optional custom namespace to use for extracted triples that define data
-                    model instances. Defaults to http://purl.org/cognite/neat/.
-    """
-
-    def __init__(
-        self,
-        filepath: Path | str,
-        base_namespace: str | None = None,
-    ):
-        self.filepath = Path(filepath)
-        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else PREFIXES["neat"]
-
-    def extract(self) -> set[Triple]:
-        """
-        Extracts RDF triples from the graph capturing sheet.
-
-        Returns:
-            List of RDF triples, represented as tuples `(subject, predicate, object)`, that define data model instances
-        """
-        if self.filepath is None:
-            raise ValueError("File path to the graph capturing sheet is not provided!")
-
-        root = ET.parse(self.filepath).getroot()
-
-        nodes, edges = _extract_nodes_and_edges(root)
-
-        self.nodes = nodes
-
-        return _to_triples(nodes, edges, base_namespace=self.namespace)
-
-
-def _extract_nodes_and_edges(root: Element) -> tuple[dict, dict]:
-    """Extract nodes and edges from an XML tree.
-
-    Args:
-        root: XML tree to extract nodes and edges from.
-
-    Returns:
-        Tuple of nodes and edges.
-    """
-    nodes: dict = {}
-    edges: dict = {"associations": set(), "connections": set(), "children": set()}
-
-    for element in iterate_tree(root):
-        if (
-            "ComponentClass" in element.attrib
-            and element.attrib["ComponentClass"] != "Label"
-            and "ID" in element.attrib
-        ):
-            id_ = element.attrib["ID"]
-
-            # add header that contains things such as type
-            nodes[id_] = {"header": element.attrib, "attributes": {}}
-            nodes[id_]["header"]["tag"] = str(element.tag)
-
-            # add human readable label of node (if exists)
-            nodes = _add_node_label(id_, nodes, element)
-
-            # add generic attributes of node
-            nodes = _add_node_generic_attributes(id_, nodes, element)
-
-            # edges scenario: <Connection> tag
-            edges = _add_connection_edge(edges, element)
-
-            # edges scenario: <Association> tag
-            edges = _add_association_edge(id_, edges, element)
-
-            # edge scenario: children elements of the element
-            edges = _add_child_edge(id_, edges, element)
-
-    return nodes, edges
-
-
-def _add_node_label(id_: str, nodes: dict, element: Element) -> dict:
-    if children := get_children(element, "Label", 1):
-        if grandchildren := get_children(children[0], "Text", 1):
-            if "String" in grandchildren[0].attrib:
-                nodes[id_]["header"]["label"] = grandchildren[0].attrib["String"]
-    # extension for schema version 3.3, where text is used to "label" without a <label> parent
-    elif children := get_children(element, "Text", 1):
-        if "String" in children[0].attrib:
-            nodes[id_]["header"]["label"] = children[0].attrib["String"]
-
-    return nodes
-
-
-def _add_node_generic_attributes(id_: str, nodes: dict, element: Element) -> dict:
-    if children := get_children(element, "GenericAttributes", 1):
-        if grandchildren := get_children(children[0], "GenericAttribute"):
-            for generic_attribute in grandchildren:
-                # extension for schema version 3.3, where "AttributeURI" is not included
-                if "AttributeURI" in generic_attribute.attrib:
-                    if generic_attribute.attrib["AttributeURI"] not in nodes[id_]:
-                        nodes[id_]["attributes"][generic_attribute.attrib["AttributeURI"]] = [generic_attribute.attrib]
-                    else:
-                        nodes[id_]["attributes"][generic_attribute.attrib["AttributeURI"]].append(
-                            generic_attribute.attrib
-                        )
-
-    return nodes
-
-
-def _add_connection_edge(edges: dict, element: Element) -> dict:
-    if "connections" not in edges:
-        edges["connections"] = set()
-
-    if connections := get_children(element, "Connection"):
-        for connection in connections:
-            if "FromID" in connection.attrib and "ToID" in connection.attrib:
-                edges["connections"].add((connection.attrib["FromID"], "connection", connection.attrib["ToID"]))
-
-    return edges
-
-
-def _add_association_edge(id_: str, edges: dict, element: Element) -> dict:
-    if "associations" not in edges:
-        edges["associations"] = set()
-
-    if associations := get_children(element, "Association"):
-        for association in associations:
-            if "Type" in association.attrib and "ItemID" in association.attrib:
-                association_type = "".join(
-                    [
-                        word.capitalize() if i != 0 else word
-                        for i, word in enumerate(association.attrib["Type"].split(" "))
-                    ]
-                )
-                edges["associations"].add((id_, f"{association_type}", association.attrib["ItemID"]))
-
-    return edges
-
-
-def _add_child_edge(id_: str, edges: dict, element: Element) -> dict:
-    if "children" not in edges:
-        edges["children"] = set()
-
-    for child in element:
-        if "ID" in child.attrib and child.tag != "Label":
-            edges["children"].add((id_, child.tag, child.attrib["ID"]))
-
-    return edges
-
-
-def _to_triples(nodes: dict, edges: dict, base_namespace: Namespace) -> set[Triple]:
-    """Convert nodes and edges to subject-predicate-object triples.
-
-    Args:
-        nodes: Nodes to convert to triples.
-        edges: Edges to convert to triples.
-
-    Returns:
-        List of triples.
-    """
-    triples: set[Triple] = set()
-
-    # Adding nodes and nodes attributes
-    for id_, node in nodes.items():
-        uri = URIRef(base_namespace + id_)
-
-        # add header attribute triples
-        triples = _add_header_triples(uri, triples, node["header"], "ComponentClassURI", RDF.type)
-        triples = _add_header_triples(uri, triples, node["header"], "label", RDFS.label)
-        triples = _add_header_triples(uri, triples, node["header"], "tag")
-        triples = _add_header_triples(uri, triples, node["header"], "ComponentClass")
-        triples = _add_header_triples(uri, triples, node["header"], "ComponentName")
-
-        # add generic attribute triples
-        for attribute, values in node["attributes"].items():
-            attribute_uri, triples = _to_compliant_attribute_uri(URIRef(attribute), triples)
-
-            for value in values:
-                triples = _add_attribute_triples(uri, triples, attribute_uri, value)
-
-    # Adding Edges
-    triples = _add_edge_triples(edges["connections"], triples, "connections", base_namespace)
-    triples = _add_edge_triples(edges["associations"], triples, "associations", base_namespace)
-    triples = _add_edge_triples(edges["children"], triples, "children", base_namespace)
-
-    return triples
-
-
-def _add_edge_triples(
-    edges: set[tuple[str, str, str]], triples: set[Triple], edge_type: str, base_namespace: Namespace
-) -> set[Triple]:
-    """Convert edges to subject-predicate-object triples.
-
-    Args:
-        edges: Edges to convert to triples.
-
-    Returns:
-        List of triples.
-    """
-
-    for subject, predicate, object in edges:
-        if edge_type != "connections":
-            predicate_uri = _DEXPI_PREFIXES["dexpi"][f"{edge_type}/{predicate}"]
-        else:
-            predicate_uri = _DEXPI_PREFIXES["dexpi"][predicate]
-
-        triples.add((URIRef(base_namespace + subject), predicate_uri, URIRef(base_namespace + object)))
-
-    return triples
-
-
-def _add_header_triples(
-    uri: URIRef, triples: set[Triple], attributes: dict, attribute: str, attribute_uri: URIRef | None = None
-) -> set[Triple]:
-    if attribute not in attributes:
-        return triples
-
-    attribute_uri = attribute_uri or _DEXPI_PREFIXES["dexpi"][attribute]
-
-    if attribute in attributes and attribute_uri == RDF.type:
-        triples.add((uri, attribute_uri, URIRef(attributes[attribute])))
-    else:
-        triples.add((uri, attribute_uri, Literal(attributes[attribute])))
-
-    return triples
-
-
-def _to_compliant_attribute_uri(attribute_uri: URIRef, triples: set[Triple]) -> tuple[URIRef, set[Triple]]:
-    namespace = get_namespace(attribute_uri)
-    id_ = remove_namespace(attribute_uri)
-    compliant_id = re.sub(ALLOWED_PATTERN, "", id_)
-    compliant_attribute_uri = URIRef(f"{namespace}{compliant_id}")
-
-    if attribute_uri != compliant_attribute_uri:
-        triples.add(
-            (
-                compliant_attribute_uri,
-                SKOS.exactMatch,
-                attribute_uri,
-            )
-        )
-        triples.add(
-            (
-                compliant_attribute_uri,
-                RDFS.comment,
-                Literal("Modified property URI to be compliant with NEAT internal representation"),
-            )
-        )
-
-    return compliant_attribute_uri, triples
-
-
-def _add_attribute_triples(uri: URIRef, triples: set[Triple], attribute_uri, value: dict) -> set[Triple]:
-    # case: when Value or Format is not present we skip the attribute since it is not formatted correctly
-    if "Value" not in value or "Format" not in value:
-        return triples
-
-    # case: when unit is present we create a special datatype for it
-    if "Units" in value:
-        triples.update(_generate_datatype_triples(_DEXPI_PREFIXES["dexpi"], value))
-        triples.add(
-            (
-                uri,
-                attribute_uri,
-                Literal(value["Value"], datatype=_DEXPI_PREFIXES["dexpi"][value["Units"]]),
-            )
-        )
-
-    # case: when language is present we create add language tag to the literal
-    elif "Language" in value and "Value" in value:
-        triples.add((uri, attribute_uri, Literal(value["Value"], lang=value["Language"])))
-
-    # case: when ValueURI is present we use it instead of Value
-    elif "ValueURI" in value:
-        triples.add((uri, attribute_uri, Literal(value["ValueURI"], datatype=XSD[value["Format"]])))
-
-    # case: when Format is not string we make sure to add the datatype
-    elif value["Format"].lower() != "string":
-        triples.add((uri, attribute_uri, Literal(value["Value"], datatype=XSD[value["Format"]])))
-
-    # case: when Format is string we add the literal without datatype (easier to read triples, less noise)
-    else:
-        triples.add((uri, attribute_uri, Literal(value["Value"])))
-
-    return triples
-
-
-def _generate_datatype_triples(base_namespace: Namespace, unit_definition: dict) -> set[Triple]:
-    return {
-        (base_namespace[unit_definition["Units"]], RDF.type, RDFS.Datatype),
-        (base_namespace[unit_definition["Units"]], RDFS.label, Literal(unit_definition["Units"])),
-        (base_namespace[unit_definition["Units"]], OWL.equivalentClass, XSD[unit_definition["Format"]]),
-        (base_namespace[unit_definition["Units"]], SKOS.exactMatch, URIRef(unit_definition["UnitsURI"])),
-    }