cognite-neat 0.92.3__py3-none-any.whl → 0.94.0__py3-none-any.whl

cognite/neat/_graph/extractors/_rdf_file.py

@@ -0,0 +1,49 @@
+from collections.abc import Iterable
+from pathlib import Path
+from typing import cast
+
+from rdflib import URIRef
+from rdflib.util import guess_format
+
+from cognite.neat._constants import DEFAULT_BASE_URI
+from cognite.neat._graph._shared import rdflib_to_mime_types
+from cognite.neat._graph.extractors._base import BaseExtractor
+from cognite.neat._graph.models import Triple
+from cognite.neat._issues._base import IssueList
+from cognite.neat._issues.errors import FileNotFoundNeatError, FileTypeUnexpectedError
+
+
+class RdfFileExtractor(BaseExtractor):
+    """Extract data from RDF files into Neat.
+
+    Args:
+        filepath (Path): The path to the RDF file.
+        mime_type (MIMETypes, optional): The MIME type of the RDF file. Defaults to "application/rdf+xml".
+        base_uri (URIRef, optional): The base URI to use. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        filepath: Path,
+        base_uri: URIRef = DEFAULT_BASE_URI,
+        issue_list: IssueList | None = None,
+    ):
+        self.issue_list = issue_list or IssueList(title=f"{filepath.name}")
+
+        self.filepath = filepath
+        self.mime_type = rdflib_to_mime_types(cast(str, guess_format(str(self.filepath))))
+        self.base_uri = base_uri
+
+        if not self.filepath.exists():
+            self.issue_list.append(FileNotFoundNeatError(self.filepath))
+
+        if not self.mime_type:
+            self.issue_list.append(
+                FileTypeUnexpectedError(
+                    self.filepath,
+                    frozenset([".rdf", ".ttl", ".nt", ".n3", ".owl", ".nq", ".trig"]),
+                )
+            )
+
+    def extract(self) -> Iterable[Triple]:
+        raise NotImplementedError()

cognite/neat/{graph → _graph}/loaders/_base.py

@@ -6,11 +6,11 @@ from typing import ClassVar, Generic, TypeVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.capabilities import Capability
 
-from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
-from cognite.neat.issues.errors import AuthorizationError
-from cognite.neat.store import NeatGraphStore
-from cognite.neat.utils.auxiliary import class_html_doc
-from cognite.neat.utils.upload import UploadResult, UploadResultList
+from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat._issues.errors import AuthorizationError
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.auxiliary import class_html_doc
+from cognite.neat._utils.upload import UploadResult, UploadResultList
 
 T_Output = TypeVar("T_Output")
 

cognite/neat/{graph → _graph}/loaders/_rdf2asset.py

@@ -17,16 +17,17 @@ from cognite.client.data_classes.capabilities import (
 )
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
 
-from cognite.neat.graph._tracking.base import Tracker
-from cognite.neat.graph._tracking.log import LogTracker
-from cognite.neat.issues import IssueList, NeatError, NeatIssue, NeatIssueList
-from cognite.neat.issues.errors import ResourceCreationError, ResourceNotFoundError
-from cognite.neat.rules.analysis._asset import AssetAnalysis
-from cognite.neat.rules.models import AssetRules
-from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
-from cognite.neat.store import NeatGraphStore
-from cognite.neat.utils.auxiliary import create_sha256_hash
-from cognite.neat.utils.upload import UploadResult
+from cognite.neat._graph._tracking.base import Tracker
+from cognite.neat._graph._tracking.log import LogTracker
+from cognite.neat._issues import IssueList, NeatError, NeatIssue, NeatIssueList
+from cognite.neat._issues.errors import ResourceCreationError, ResourceNotFoundError
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules.analysis._asset import AssetAnalysis
+from cognite.neat._rules.models import AssetRules
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.auxiliary import create_sha256_hash
+from cognite.neat._utils.upload import UploadResult
 
 from ._base import _END_OF_CLASS, CDFLoader
 

cognite/neat/{graph → _graph}/loaders/_rdf2dms.py

@@ -15,21 +15,21 @@ from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 from rdflib import RDF
 
-from cognite.neat.graph._tracking import LogTracker, Tracker
-from cognite.neat.graph.models import InstanceType
-from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
-from cognite.neat.issues.errors import (
+from cognite.neat._graph._tracking import LogTracker, Tracker
+from cognite.neat._graph.models import InstanceType
+from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat._issues.errors import (
     ResourceConvertionError,
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceRetrievalError,
 )
-from cognite.neat.issues.warnings import PropertyTypeNotSupportedWarning
-from cognite.neat.rules.models import DMSRules
-from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
-from cognite.neat.store import NeatGraphStore
-from cognite.neat.utils.auxiliary import create_sha256_hash
-from cognite.neat.utils.upload import UploadResult
+from cognite.neat._issues.warnings import PropertyTypeNotSupportedWarning
+from cognite.neat._rules.models import DMSRules
+from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.auxiliary import create_sha256_hash
+from cognite.neat._utils.upload import UploadResult
 
 from ._base import CDFLoader
 

cognite/neat/{graph → _graph}/queries/_base.py

@@ -1,15 +1,18 @@
 import warnings
 from collections import defaultdict
+from collections.abc import Iterable
 from typing import Literal, cast, overload
 
-from rdflib import RDF, Graph, URIRef
+from rdflib import RDF, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 from rdflib.query import ResultRow
 
-from cognite.neat.graph.models import InstanceType
-from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
-from cognite.neat.rules.models.information import InformationRules
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._constants import UNKNOWN_TYPE
+from cognite.neat._graph.models import InstanceType
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._rules.models.information import InformationRules
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._construct import build_construct_query
 
@@ -71,30 +74,69 @@ class Queries:
         # Select queries gives an iterable of result rows
         return cast(list[ResultRow], list(self.graph.query(query)))
 
-    def triples_of_type_instances(self, rdf_type: str) -> list[tuple[str, str, str]]:
+    def triples_of_type_instances(self, rdf_type: str | URIRef) -> list[tuple[str, str, str]]:
         """Get all triples of a given type.
 
         This method assumes the graph has been transformed into the default namespace.
         """
-
-        if self.rules:
-            query = (
-                f"SELECT ?instance ?prop ?value "
-                f"WHERE {{ ?instance a <{self.rules.metadata.namespace[rdf_type]}> . ?instance ?prop ?value . }} "
-                "order by ?instance"
-            )
-
-            result = self.graph.query(query)
-
-            # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace_from_uri(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+        if isinstance(rdf_type, URIRef):
+            rdf_uri = rdf_type
+        elif isinstance(rdf_type, str) and self.rules:
+            rdf_uri = self.rules.metadata.namespace[rdf_type]
         else:
             warnings.warn(
-                "No rules found for the graph store, returning empty list.",
+                "Unknown namespace. Please either provide a URIRef or set the rules of the store.",
                 stacklevel=2,
             )
             return []
 
+        query = (
+            "SELECT ?instance ?prop ?value "
+            f"WHERE {{ ?instance a <{rdf_uri}> . ?instance ?prop ?value . }} "
+            "order by ?instance"
+        )
+
+        result = self.graph.query(query)
+
+        # We cannot include the RDF.type in case there is a neat:type property
+        return [remove_namespace_from_uri(list(triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
+
+    def types_with_property(self, property_uri: URIRef) -> list[URIRef]:
+        """Check if a property exists in the graph store
+
+        Args:
+            property_uri: Property URI to check
+
+        Returns:
+            True if property exists, False otherwise
+        """
+        query = f"SELECT DISTINCT ?t WHERE {{ ?s <{property_uri}> ?o ; a ?t}} Limit 1"
+        return cast(list[URIRef], [t[0] for t in self.graph.query(query)])  # type: ignore[index]
+
+    def has_namespace(self, namespace: Namespace) -> bool:
+        """Check if a namespace exists in the graph store
+
+        Args:
+            namespace: Namespace to check
+
+        Returns:
+            True if namespace exists, False otherwise
+        """
+        query = f"ASK WHERE {{ ?s ?p ?o . FILTER(STRSTARTS(STR(?p), STR(<{namespace}>))) }}"
+        return bool(self.graph.query(query))
+
+    def has_type(self, type_: URIRef) -> bool:
+        """Check if a type exists in the graph store
+
+        Args:
+            type_: Type to check
+
+        Returns:
+            True if type exists, False otherwise
+        """
+        query = f"ASK WHERE {{ ?s a <{type_}> }}"
+        return bool(self.graph.query(query))
+
     def describe(
         self,
         instance_id: URIRef,
@@ -249,3 +291,33 @@ class Queries:
         if remove_namespace:
             return [remove_namespace_from_uri(res[0]) for res in result]
         return result
+
+    def multi_value_type_property(
+        self,
+    ) -> Iterable[tuple[URIRef, URIRef, list[URIRef]]]:
+        query = """SELECT ?sourceType ?property
+                          (GROUP_CONCAT(DISTINCT STR(?valueType); SEPARATOR=",") AS ?valueTypes)
+
+                   WHERE {{
+                       ?s ?property ?o .
+                       ?s a ?sourceType .
+                       OPTIONAL {{ ?o a ?type }}
+
+                       # Key part to determine value type: either object, data or unknown
+                       BIND(   IF(isLiteral(?o),DATATYPE(?o),
+                               IF(BOUND(?type), ?type,
+                                               <{unknownType}>)) AS ?valueType)
+                   }}
+
+                   GROUP BY ?sourceType ?property
+                   HAVING (COUNT(DISTINCT ?valueType) > 1)"""
+
+        for (
+            source_type,
+            property_,
+            value_types,
+        ) in cast(
+            ResultRow,
+            self.graph.query(query.format(unknownType=str(UNKNOWN_TYPE))),
+        ):
+            yield cast(URIRef, source_type), cast(URIRef, property_), [URIRef(uri) for uri in value_types.split(",")]

cognite/neat/{graph → _graph}/queries/_construct.py

@@ -3,17 +3,17 @@ from typing import cast
 
 from rdflib import Graph, URIRef
 
-from cognite.neat.rules.analysis import InformationAnalysis
-from cognite.neat.rules.models._rdfpath import (
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models._rdfpath import (
     Hop,
     RDFPath,
     SelfReferenceProperty,
     SingleProperty,
     Traversal,
 )
-from cognite.neat.rules.models.entities import ClassEntity
-from cognite.neat.rules.models.information import InformationProperty, InformationRules
-from cognite.neat.utils.collection_ import most_occurring_element
+from cognite.neat._rules.models.entities import ClassEntity
+from cognite.neat._rules.models.information import InformationProperty, InformationRules
+from cognite.neat._utils.collection_ import most_occurring_element
 
 from ._shared import Triple, hop2property_path
 

cognite/neat/{graph → _graph}/queries/_shared.py

@@ -6,12 +6,12 @@ from pydantic import BaseModel, ConfigDict, Field
 from rdflib import Graph, Literal, Namespace
 from rdflib.term import URIRef
 
-from cognite.neat.constants import get_default_prefixes
-from cognite.neat.rules.models._rdfpath import (
+from cognite.neat._constants import get_default_prefixes
+from cognite.neat._rules.models._rdfpath import (
     Hop,
     Step,
 )
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite/neat/{graph → _graph}/transformers/__init__.py

@@ -5,8 +5,10 @@ from ._classic_cdf import (
     AssetRelationshipConnector,
     AssetSequenceConnector,
     AssetTimeSeriesConnector,
+    RelationshipToSchemaTransformer,
 )
 from ._rdfpath import AddSelfReferenceProperty
+from ._value_type import SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -16,6 +18,8 @@ __all__ = [
     "AssetEventConnector",
     "AssetRelationshipConnector",
     "AddSelfReferenceProperty",
+    "SplitMultiValueProperty",
+    "RelationshipToSchemaTransformer",
 ]
 
 Transformers = (
@@ -26,4 +30,6 @@ Transformers = (
     | AssetEventConnector
     | AssetRelationshipConnector
     | AddSelfReferenceProperty
+    | SplitMultiValueProperty
+    | RelationshipToSchemaTransformer
 )

cognite/neat/{graph → _graph}/transformers/_classic_cdf.py

@@ -1,9 +1,13 @@
+import warnings
 from typing import cast
 
-from rdflib import RDF, Graph, Literal, URIRef
+from rdflib import RDF, Graph, Literal, Namespace, URIRef
+from rdflib.query import ResultRow
 
-from cognite.neat.constants import DEFAULT_NAMESPACE
-from cognite.neat.graph import extractors
+from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
+from cognite.neat._graph import extractors
+from cognite.neat._issues.warnings import ResourceNotFoundWarning
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseTransformer
 
@@ -313,3 +317,131 @@ class AssetRelationshipConnector(BaseTransformer):
                     # remove properties that are not needed, specifically the external ids
                     graph.remove((relationship_id, self.relationship_source_xid_prop, None))
                     graph.remove((relationship_id, self.relationship_target_xid_prop, None))
+
+
+class RelationshipToSchemaTransformer(BaseTransformer):
+    """Replaces relationships with a schema.
+
+    This transformer analyzes the relationships in the graph and modifies them to be part of the schema
+    for Assets, Events, Files, Sequences, and TimeSeries. Relationships without any properties
+    are replaced by a simple relationship between the source and target nodes. Relationships with
+    properties are replaced by a schema that contains the properties as attributes.
+
+    Args:
+        limit: The minimum number of relationships that need to be present for it
+            to be converted into a schema. Default is 1.
+
+    """
+
+    def __init__(self, limit: int = 1, namespace: Namespace = CLASSIC_CDF_NAMESPACE) -> None:
+        self._limit = limit
+        self._namespace = namespace
+
+    _NOT_PROPERTIES: frozenset[str] = frozenset(
+        {"source_external_id", "target_external_id", "external_id", "source_type", "target_type"}
+    )
+    _RELATIONSHIP_NODE_TYPES: tuple[str, ...] = tuple(["Asset", "Event", "File", "Sequence", "TimeSeries"])
+    description = "Replaces relationships with a schema"
+    _use_only_once: bool = True
+    _need_changes = frozenset({str(extractors.RelationshipsExtractor.__name__)})
+
+    _count_by_source_target = """PREFIX classic: <{namespace}>
+
+SELECT (COUNT(?instance) AS ?instanceCount)
+WHERE {{
+  ?instance a classic:Relationship .
+  ?instance classic:source_type classic:{source_type} .
+  ?instance classic:target_type classic:{target_type} .
+}}"""
+
+    _instances = """PREFIX classic: <{namespace}>
+
+SELECT ?instance
+WHERE {{
+    ?instance a classic:Relationship .
+    ?instance classic:source_type classic:{source_type} .
+    ?instance classic:target_type classic:{target_type} .
+}}"""
+    _lookup_entity_query = """PREFIX classic: <{namespace}>
+
+SELECT ?entity
+WHERE {{
+    ?entity a classic:{entity_type} .
+    ?entity classic:external_id "{external_id}" .
+}}"""
+
+    def transform(self, graph: Graph) -> None:
+        for source_type in self._RELATIONSHIP_NODE_TYPES:
+            for target_type in self._RELATIONSHIP_NODE_TYPES:
+                query = self._count_by_source_target.format(
+                    namespace=self._namespace, source_type=source_type, target_type=target_type
+                )
+                for instance_count in graph.query(query):
+                    if int(instance_count[0]) < self._limit:  # type: ignore[index, arg-type]
+                        continue
+                    query = self._instances.format(
+                        namespace=self._namespace, source_type=source_type, target_type=target_type
+                    )
+                    for result in graph.query(query):
+                        instance_id = cast(URIRef, result[0])  # type: ignore[index, misc]
+                        self._convert_relationship_to_schema(graph, instance_id, source_type, target_type)
+
+    def _convert_relationship_to_schema(
+        self, graph: Graph, instance_id: URIRef, source_type: str, target_type: str
+    ) -> None:
+        result = cast(list[ResultRow], list(graph.query(f"DESCRIBE <{instance_id}>")))
+        object_by_predicates = cast(
+            dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in result}
+        )
+        source_external_id = cast(URIRef, object_by_predicates["source_external_id"])
+        target_source_id = cast(URIRef, object_by_predicates["target_external_id"])
+        try:
+            source_id = self._lookup_entity(graph, source_type, source_external_id)
+        except ValueError:
+            warnings.warn(ResourceNotFoundWarning(source_external_id, "class", str(instance_id), "class"), stacklevel=2)
+            return None
+        try:
+            target_id = self._lookup_entity(graph, target_type, target_source_id)
+        except ValueError:
+            warnings.warn(ResourceNotFoundWarning(target_source_id, "class", str(instance_id), "class"), stacklevel=2)
+            return None
+        external_id = str(object_by_predicates["external_id"])
+        # If there is properties on the relationship, we create a new intermediate node
+        self._create_node(graph, object_by_predicates, external_id, source_id, target_id, self._predicate(target_type))
+
+        for triple in result:
+            graph.remove(triple)  # type: ignore[arg-type]
+
+    def _lookup_entity(self, graph: Graph, entity_type: str, external_id: str) -> URIRef:
+        query = self._lookup_entity_query.format(
+            namespace=self._namespace, entity_type=entity_type, external_id=external_id
+        )
+        result = list(graph.query(query))
+        if len(result) == 1:
+            return cast(URIRef, result[0][0])  # type: ignore[index]
+        raise ValueError(f"Could not find entity with external_id {external_id} and type {entity_type}")
+
+    def _create_node(
+        self,
+        graph: Graph,
+        objects_by_predicates: dict[str, URIRef | Literal],
+        external_id: str,
+        source_id: URIRef,
+        target_id: URIRef,
+        predicate: URIRef,
+    ) -> None:
+        """Creates a new intermediate node for the relationship with properties."""
+        # Create new node
+        instance_id = self._namespace[external_id]
+        graph.add((instance_id, RDF.type, self._namespace["Edge"]))
+        for prop_name, object_ in objects_by_predicates.items():
+            if prop_name in self._NOT_PROPERTIES:
+                continue
+            graph.add((instance_id, self._namespace[prop_name], object_))
+
+        # Connect the new node to the source and target nodes
+        graph.add((source_id, predicate, instance_id))
+        graph.add((instance_id, self._namespace["end_node"], target_id))
+
+    def _predicate(self, target_type: str) -> URIRef:
+        return self._namespace[f"relationship{target_type.capitalize()}"]

cognite/neat/_graph/transformers/_iodd.py

@@ -0,0 +1,25 @@
+from rdflib import Namespace
+
+from cognite.neat._graph.extractors import IODDExtractor
+
+from ._prune_graph import PruneDanglingNodes, TwoHopFlattener
+
+IODD = Namespace("http://www.io-link.com/IODD/2010/10/")
+
+
+class IODDTwoHopFlattener(TwoHopFlattener):
+    _need_changes = frozenset(
+        {
+            str(IODDExtractor.__name__),
+        }
+    )
+
+    def __init__(self):
+        super().__init__(destination_node_type=IODD.TextObject, property_predicate=IODD.value, property_name="value")
+
+
+class IODDPruneDanglingNodes(PruneDanglingNodes):
+    _need_changes = frozenset({str(IODDExtractor.__name__), str(IODDTwoHopFlattener.__name__)})
+
+    def __init__(self):
+        super().__init__(node_prune_types=[IODD.TextObject])

cognite/neat/_graph/transformers/_prune_graph.py

@@ -0,0 +1,126 @@
+from rdflib import Graph, Namespace, URIRef
+from rdflib.query import ResultRow
+from rdflib.term import Identifier
+
+from ._base import BaseTransformer
+
+
+# TODO: Handle the cse when value is None, which will not make the TextObject resolve
+class TwoHopFlattener(BaseTransformer):
+    """
+    Transformer that will flatten the distance between a source node, an intermediate connecting node, and a
+    target property that is connected to the intermediate node.
+    The transformation result is that the target property is attached directly to the source node, instead of having
+    to go via the intermediate node.
+    The user can also provide a flag to decide if the intermediate node should be removed from the graph or not
+    after connecting the target property to the source node.
+
+        Ex. TwoHopFlattener:
+
+        Graph before flattening (with deletion of intermediate node):
+        node(A, rdf:type(Pump)) -(predicate("vendor"))>
+                                node(B, rdf:type(TextObject)) -(predicate("value"))> Literal("CompanyX")
+
+        Graph after flattening nodes with destination_node_type = rdf:type(TextObject), property_predicate = :value,
+        and property_name = "value":
+
+        node(A, rdf:type(Pump)) -(predicate("vendor"))> Literal("CompanyX")
+
+    Args:
+        destination_node_type: RDF.type of edge Node
+        property_predicate: Predicate to use when resolving the value from the edge node
+        property_name: name of the property that the intermediate node is pointing to
+        delete_connecting_node: bool if the intermediate Node and Edge between source Node
+                                and target property should be deleted. Defaults to True.
+    """
+
+    description: str = "Prunes the graph of specified node types that do not have connections to other nodes."
+    _query_template: str = """SELECT ?sourceNode ?property ?destinationNode ?value WHERE {{
+                                     ?sourceNode ?property ?destinationNode .
+                                     ?destinationNode a <{destination_node_type}> .
+                                     ?destinationNode <{property_predicate}> ?{property_name} . }}"""
+
+    def __init__(
+        self,
+        destination_node_type: URIRef,
+        property_predicate: Namespace,
+        property_name: str,
+        delete_connecting_node: bool = True,
+    ):
+        self.destination_node_type = destination_node_type
+        self.property_predicate = property_predicate
+        self.property_name = property_name
+        self.delete_connecting_node = delete_connecting_node
+
+    def transform(self, graph: Graph) -> None:
+        nodes_to_delete: list[Identifier] = []
+
+        graph_traversals = list(
+            graph.query(
+                self._query_template.format(
+                    destination_node_type=self.destination_node_type,
+                    property_predicate=self.property_predicate,
+                    property_name=self.property_name,
+                )
+            )
+        )
+
+        for path in graph_traversals:
+            if isinstance(path, ResultRow):
+                source_node, predicate, destination_node, property_value = path.asdict().values()
+
+                # Create new connection from source node to value
+                graph.add((source_node, predicate, property_value))
+                nodes_to_delete.append(destination_node)
+
+            if self.delete_connecting_node:
+                for node in nodes_to_delete:
+                    # Remove edge triples to node
+                    graph.remove((None, None, node))
+                    # Remove node triple
+                    graph.remove((node, None, None))
+
+
+class PruneDanglingNodes(BaseTransformer):
+    """
+    Knowledge graph pruner and resolver. Will remove rdf triples from graph that does not have connections
+    to other nodes, and traverse graph for specified types to resolve the value in the final node and link it to
+    the source node.
+
+        Ex. PruneDanglingNodes
+
+        Graph before pruning:
+        node(A, rdf:type(Pump)) -> node(B, rdf:type(Disc)),
+        node(C, rdf:type(Disc))
+
+        Graph after pruning of nodes rdf:type(Disc):
+
+        node(A, rd:type(Pump)) -> node(B, rdf:type(Disc))
+
+    Args:
+        node_prune_types: list of RDF types to prune from the Graph if they are stand-alone Nodes
+    """
+
+    description: str = "Prunes the graph of specified rdf types that do not have connections to other nodes."
+    _query_template = """
+                    SELECT ?subject
+                    WHERE {{
+                        ?subject a <{rdf_type}> .
+                        FILTER NOT EXISTS {{ ?s ?p ?subject }}
+                    }}
+            """
+
+    def __init__(
+        self,
+        node_prune_types: list[URIRef],
+    ):
+        self.node_prune_types = node_prune_types
+
+    def transform(self, graph: Graph) -> None:
+        for object_type in self.node_prune_types:
+            nodes_without_neighbours = list(graph.query(self._query_template.format(rdf_type=object_type)))
+
+            for node in nodes_without_neighbours:
+                # Remove node and its property triples in the graph
+                if isinstance(node, ResultRow):
+                    graph.remove(triple=(node["subject"], None, None))

cognite/neat/{graph → _graph}/transformers/_rdfpath.py

@@ -1,8 +1,8 @@
 from rdflib import Graph
 
-from cognite.neat.rules.analysis import InformationAnalysis
-from cognite.neat.rules.models._rdfpath import RDFPath, SingleProperty
-from cognite.neat.rules.models.information import InformationRules
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
+from cognite.neat._rules.models.information import InformationRules
 
 from ._base import BaseTransformer