cognite-neat 0.100.1__tar.gz → 0.102.0__tar.gz

cognite_neat-0.102.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cognite-neat
+Version: 0.102.0
+Summary: Knowledge graph transformation
+Home-page: https://cognite-neat.readthedocs-hosted.com/
+License: Apache-2.0
+Author: Nikola Vasiljevic
+Author-email: nikola.vasiljevic@cognite.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: all
+Provides-Extra: docs
+Provides-Extra: google
+Provides-Extra: oxi
+Provides-Extra: service
+Requires-Dist: PyYAML
+Requires-Dist: backports.strenum (>=1.2,<2.0) ; python_version < "3.11"
+Requires-Dist: cognite-sdk (>=7.54.6,<8.0.0)
+Requires-Dist: elementpath (>=4.0.0,<5.0.0)
+Requires-Dist: exceptiongroup (>=1.1.3,<2.0.0) ; python_version < "3.11"
+Requires-Dist: fastapi (>=0,<1) ; extra == "service" or extra == "all"
+Requires-Dist: google-api-python-client ; extra == "google"
+Requires-Dist: google-auth-oauthlib ; extra == "google"
+Requires-Dist: gspread ; extra == "google"
+Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
+Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
+Requires-Dist: mixpanel (>=4.10.1,<5.0.0)
+Requires-Dist: mkdocs ; extra == "docs"
+Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
+Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"
+Requires-Dist: mkdocs-git-revision-date-localized-plugin ; extra == "docs"
+Requires-Dist: mkdocs-gitbook ; extra == "docs"
+Requires-Dist: mkdocs-glightbox ; extra == "docs"
+Requires-Dist: mkdocs-jupyter ; extra == "docs"
+Requires-Dist: mkdocs-material-extensions ; extra == "docs"
+Requires-Dist: mkdocstrings[python] ; extra == "docs"
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
+Requires-Dist: openpyxl
+Requires-Dist: oxrdflib[oxigraph] (>=0.4.0,<0.5.0) ; extra == "oxi" or extra == "all"
+Requires-Dist: packaging (>=22.0,<25.0)
+Requires-Dist: pandas
+Requires-Dist: prometheus-client (>=0,<1) ; extra == "service" or extra == "all"
+Requires-Dist: pydantic (>=2,<3)
+Requires-Dist: pymdown-extensions ; extra == "docs"
+Requires-Dist: pyoxigraph (==0.4.3) ; extra == "oxi" or extra == "all"
+Requires-Dist: python-multipart (==0.0.9) ; extra == "service" or extra == "all"
+Requires-Dist: pyvis (>=0.3.2,<0.4.0)
+Requires-Dist: rdflib
+Requires-Dist: requests
+Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0)
+Requires-Dist: schedule (>=1,<2) ; extra == "service" or extra == "all"
+Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
+Requires-Dist: typing_extensions (>=4.8,<5.0) ; python_version < "3.11"
+Requires-Dist: urllib3 (>=2,<3)
+Requires-Dist: uvicorn[standard] (>=0,<1) ; extra == "service" or extra == "all"
+Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
+Project-URL: Repository, https://github.com/cognitedata/neat
+Description-Content-Type: text/markdown
+
+# kNowlEdge grAph Transformer (NEAT)
+
+[![release](https://img.shields.io/github/actions/workflow/status/cognitedata/neat/release.yaml?style=for-the-badge)](https://github.com/cognitedata/neat/actions/workflows/release.yaml)
+[![Documentation Status](https://readthedocs.com/projects/cognite-neat/badge/?version=latest&style=for-the-badge)](https://cognite-neat.readthedocs-hosted.com/en/latest/?badge=latest)
+[![Github](https://shields.io/badge/github-cognite/neat-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/neat)
+[![PyPI](https://img.shields.io/pypi/v/cognite-neat?style=for-the-badge)](https://pypi.org/project/cognite-neat/)
+[![Downloads](https://img.shields.io/pypi/dm/cognite-neat?style=for-the-badge)](https://pypistats.org/packages/cognite-neat)
+[![Docker Pulls](https://img.shields.io/docker/pulls/cognite/neat?style=for-the-badge)](https://hub.docker.com/r/cognite/neat)
+[![GitHub](https://img.shields.io/github/license/cognitedata/neat?style=for-the-badge)](https://github.com/cognitedata/neat/blob/master/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
+[![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)
+
+NEAT is a domain expert centric and developer friendly solution for rapid:
+
+- semantic data modeling
+- creation, transformation and enrichment of knowledge graphs
+- and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
+
+NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
+NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.
+
+> NEAT is an acronym derived from k**N**owl**Ed**ge gr**A**ph **T**ransformer hallucinated by GenAI.
+
+## Installation
+
+```bash
+pip install cognite-neat
+```
+
+## Usage
+
+The user interface for `NEAT` is a notebook-based environment. Once you have set up your notebook
+environment, you start by creating a `CogniteClient` and instantiate a `NeatSession` object.
+
+```python
+from cognite.neat import NeatSession, get_cognite_client
+
+client = get_cognite_client(".env")
+
+neat = NeatSession(client)
+
+neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
+```
+
+## Documentation
+
+For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)
+

cognite_neat-0.102.0/README.md

@@ -0,0 +1,48 @@
+# kNowlEdge grAph Transformer (NEAT)
+
+[![release](https://img.shields.io/github/actions/workflow/status/cognitedata/neat/release.yaml?style=for-the-badge)](https://github.com/cognitedata/neat/actions/workflows/release.yaml)
+[![Documentation Status](https://readthedocs.com/projects/cognite-neat/badge/?version=latest&style=for-the-badge)](https://cognite-neat.readthedocs-hosted.com/en/latest/?badge=latest)
+[![Github](https://shields.io/badge/github-cognite/neat-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/neat)
+[![PyPI](https://img.shields.io/pypi/v/cognite-neat?style=for-the-badge)](https://pypi.org/project/cognite-neat/)
+[![Downloads](https://img.shields.io/pypi/dm/cognite-neat?style=for-the-badge)](https://pypistats.org/packages/cognite-neat)
+[![Docker Pulls](https://img.shields.io/docker/pulls/cognite/neat?style=for-the-badge)](https://hub.docker.com/r/cognite/neat)
+[![GitHub](https://img.shields.io/github/license/cognitedata/neat?style=for-the-badge)](https://github.com/cognitedata/neat/blob/master/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
+[![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)
+
+NEAT is a domain expert centric and developer friendly solution for rapid:
+
+- semantic data modeling
+- creation, transformation and enrichment of knowledge graphs
+- and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)
+
+NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
+NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.
+
+> NEAT is an acronym derived from k**N**owl**Ed**ge gr**A**ph **T**ransformer hallucinated by GenAI.
+
+## Installation
+
+```bash
+pip install cognite-neat
+```
+
+## Usage
+
+The user interface for `NEAT` is a notebook-based environment. Once you have set up your notebook
+environment, you start by creating a `CogniteClient` and instantiate a `NeatSession` object.
+
+```python
+from cognite.neat import NeatSession, get_cognite_client
+
+client = get_cognite_client(".env")
+
+neat = NeatSession(client)
+
+neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
+```
+
+## Documentation
+
+For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_constants.py

@@ -71,7 +71,7 @@ UNKNOWN_TYPE = DEFAULT_NAMESPACE.UnknownType
 XML_SCHEMA_NAMESPACE = Namespace("http://www.w3.org/2001/XMLSchema#")
 
 
-def get_default_prefixes() -> dict[str, Namespace]:
+def get_default_prefixes_and_namespaces() -> dict[str, Namespace]:
     return {
         "owl": OWL._NS,
         "rdf": RDF._NS,
@@ -84,6 +84,10 @@ def get_default_prefixes() -> dict[str, Namespace]:
         "imf": Namespace("http://ns.imfid.org/imf#"),
         "pav": Namespace("http://purl.org/pav/"),
         "foaf": FOAF._NS,
+        "dexpi": Namespace("http://sandbox.dexpi.org/rdl/"),
+        "qudt": Namespace("https://qudt.org/vocab/unit/"),
+        "iodd": Namespace("http://www.io-link.com/IODD/2010/10/"),
+        "aml": Namespace("https://www.automationml.org/"),
     }
 
 

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/loaders/_rdf2dms.py

@@ -156,7 +156,6 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
             for identifier, properties in reader:
                 try:
-                    print(view_id)
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
                     error_node = ResourceCreationError(identifier, "node", error=str(e))
@@ -198,7 +197,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         json_fields: list[str] = []
         for prop_name, prop in view.properties.items():
             if isinstance(prop, dm.EdgeConnection):
-                edge_by_property[prop.type.external_id] = prop_name, prop
+                edge_by_property[prop_name] = prop_name, prop
             if isinstance(prop, dm.MappedProperty):
                 if isinstance(prop.type, dm.DirectRelation):
                     direct_relation_by_property[prop_name] = prop.type

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/queries/_base.py

@@ -209,7 +209,10 @@ class Queries:
             elif (
                 isinstance(object_, URIRef)
                 and property_types
-                and property_types.get(property_, None) == EntityTypes.object_property
+                and (
+                    property_types.get(property_, None) == EntityTypes.object_property
+                    or property_types.get(property_, None) == EntityTypes.undefined
+                )
             ):
                 value = remove_namespace_from_uri(object_, validation="prefix")
 
@@ -233,7 +236,6 @@ class Queries:
                 else:
                     # we should not have multiple rdf:type values
                     continue
-
         if property_values:
             return (
                 identifier,
@@ -358,3 +360,21 @@ class Queries:
             dropped_types[t] = len(instance_ids)
             remove_instance_ids_in_batch(self.graph, instance_ids)
         return dropped_types
+
+    def multi_type_instances(self) -> dict[str, list[str]]:
+        """Find instances with multiple types"""
+
+        query = """
+        SELECT ?instance (GROUP_CONCAT(str(?type); SEPARATOR=",") AS ?types)
+        WHERE {
+            ?instance a ?type .
+        }
+        GROUP BY ?instance
+        HAVING (COUNT(?type) > 1)
+        """
+
+        result = {}
+        for instance, types in self.graph.query(query):  # type: ignore
+            result[remove_namespace_from_uri(instance)] = remove_namespace_from_uri(types.split(","))
+
+        return result

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/queries/_shared.py

@@ -6,7 +6,7 @@ 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._constants import get_default_prefixes_and_namespaces
 from cognite.neat._rules.models._rdfpath import (
     Hop,
     Step,
@@ -51,7 +51,7 @@ def generate_prefix_header(prefixes: dict[str, Namespace] | None = None) -> str:
         Prefix header
     """
 
-    prefixes = prefixes or get_default_prefixes()
+    prefixes = prefixes or get_default_prefixes_and_namespaces()
 
     return "".join(f"PREFIX {key}:<{value}>\n" for key, value in prefixes.items())
 
@@ -81,7 +81,7 @@ def get_predicate_id(
         ID of predicate (aka property) connecting subject and object
     """
 
-    prefixes = prefixes or get_default_prefixes()
+    prefixes = prefixes or get_default_prefixes_and_namespaces()
 
     query = """
 
@@ -123,7 +123,7 @@ def hop2property_path(
     str
         Property path string for hop traversal (e.g. ^rdf:type/rdfs:subClassOf)
     """
-    prefixes = prefixes if prefixes else get_default_prefixes()
+    prefixes = prefixes if prefixes else get_default_prefixes_and_namespaces()
 
     # setting previous step to origin, as we are starting from there
     previous_step = Step(class_=hop.class_, direction="origin")

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/transformers/__init__.py

@@ -7,6 +7,13 @@ from ._classic_cdf import (
     AssetTimeSeriesConnector,
     RelationshipAsEdgeTransformer,
 )
+from ._prune_graph import (
+    AttachPropertyFromTargetToSource,
+    PruneDanglingNodes,
+    PruneDeadEndEdges,
+    PruneInstancesOfUnknownType,
+    PruneTypes,
+)
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
 from ._value_type import SplitMultiValueProperty
 
@@ -21,6 +28,11 @@ __all__ = [
     "SplitMultiValueProperty",
     "RelationshipAsEdgeTransformer",
     "MakeConnectionOnExactMatch",
+    "AttachPropertyFromTargetToSource",
+    "PruneDanglingNodes",
+    "PruneTypes",
+    "PruneDeadEndEdges",
+    "PruneInstancesOfUnknownType",
 ]
 
 Transformers = (
@@ -34,4 +46,9 @@ Transformers = (
     | SplitMultiValueProperty
     | RelationshipAsEdgeTransformer
     | MakeConnectionOnExactMatch
+    | AttachPropertyFromTargetToSource
+    | PruneDanglingNodes
+    | PruneTypes
+    | PruneDeadEndEdges
+    | PruneInstancesOfUnknownType
 )

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/transformers/_base.py

@@ -6,7 +6,7 @@ from rdflib import Graph
 
 class BaseTransformer(ABC):
     description: str
-    _use_only_once: bool
+    _use_only_once: bool = False
     _need_changes: ClassVar[frozenset[str]] = frozenset()
 
     @abstractmethod

{cognite_neat-0.100.1 → cognite_neat-0.102.0}/cognite/neat/_graph/transformers/_iodd.py

@@ -2,12 +2,12 @@ from rdflib import Namespace
 
 from cognite.neat._graph.extractors import IODDExtractor
 
-from ._prune_graph import PruneDanglingNodes, TwoHopFlattener
+from ._prune_graph import AttachPropertyFromTargetToSource, PruneDanglingNodes
 
 IODD = Namespace("http://www.io-link.com/IODD/2010/10/")
 
 
-class IODDTwoHopFlattener(TwoHopFlattener):
+class IODDAttachPropertyFromTargetToSource(AttachPropertyFromTargetToSource):
     _need_changes = frozenset(
         {
             str(IODDExtractor.__name__),
@@ -15,11 +15,16 @@ class IODDTwoHopFlattener(TwoHopFlattener):
     )
 
     def __init__(self):
-        super().__init__(destination_node_type=IODD.TextObject, property_predicate=IODD.value, property_name="value")
+        super().__init__(
+            target_node_type=IODD.TextObject,
+            target_property=IODD.value,
+            delete_target_node=True,
+            namespace=IODD,
+        )
 
 
 class IODDPruneDanglingNodes(PruneDanglingNodes):
-    _need_changes = frozenset({str(IODDExtractor.__name__), str(IODDTwoHopFlattener.__name__)})
+    _need_changes = frozenset({str(IODDExtractor.__name__), str(IODDAttachPropertyFromTargetToSource.__name__)})
 
     def __init__(self):
         super().__init__(node_prune_types=[IODD.TextObject])

cognite_neat-0.102.0/cognite/neat/_graph/transformers/_prune_graph.py

@@ -0,0 +1,257 @@
+from typing import cast
+
+from rdflib import Graph, Namespace, URIRef
+
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._shared import Triple
+from cognite.neat._utils.rdf_ import as_neat_compliant_uri
+from cognite.neat._utils.text import sentence_or_string_to_camel
+
+from ._base import BaseTransformer
+
+
+class AttachPropertyFromTargetToSource(BaseTransformer):
+    """
+    Transformer that considers a TargetNode and SourceNode relationship, to extract a property that is attached to
+    the TargetNode, and attaches it to the SourceNode instead, while also deleting the edge between
+    the SourceNode and TargetNode.
+    This means that you no longer have to go via the SourceNode to TargetNode to extract
+    the desired property from TargetNode, you can get it directly from the SourceNode instead.
+    Further, there are two ways of defining the predicate for the new property to attach to
+    the SourceNode. The predicate that is used will either be the old predicate between the SourceNode and TargetNode,
+    or, the TargetNode may hold a property with a value for the new predicate to use.
+    In this case, the user must specify the name of this predicate property connected to the TargetNode.
+    Consider the following example for illustration:
+
+        Ex. AttachPropertyFromTargetToSource
+        Graph before transformation:
+
+            :SourceNode a :SourceType .
+            :SourceNode :sourceProperty :TargetNode .
+
+            :TargetNode a :TargetType .
+            :TargetNode :propertyWhichValueWeWant 'Target Value' .
+            :TargetNode :propertyWhichValueWeMightWantAsNameForNewProperty 'PropertyName'
+
+        Use case A after transformation - attach new property to SourceNode using old predicate:
+
+            :SourceNode a :SourceType .
+            :SourceNode :sourceProperty 'Target Value' .
+
+        Use case B after transformation - extract new predicate from one of the properties of the TargetNode:
+
+            :SourceNode a :SourceType .
+            :SourceNode :PropertyName 'Target Value' .
+
+
+    The user can provide a flag to decide if the intermediate target node should be removed from the graph or not
+    after connecting the target property to the source node. The example illustrates this.
+    The default however is False.
+
+    If delete_target_node is not set, the expected number of triples after this transformation should be the same as
+    before the transformation.
+
+    If delete_target_node is set, the expected number of triples should be:
+        #triples_before - #target_nodes * #target_nodes_properties
+
+        Number of triples after operation from above example: 5 - 1*3 = 2
+
+    Args:
+        target_node_type: RDF.type of edge Node
+        target_property: URIRef of the property that holds the value attached to the intermediate node
+        target_property_holding_new_property: URIRef of the property which value will be new
+        property that will be added to the source node
+        delete_target_node: bool if the intermediate Node and Edge between source Node
+                                and target property should be deleted. Defaults to False.
+        convert_literal_to_uri: bool if the value of the new property should be converted to URIRef. Defaults to False.
+        namespace: Namespace to use when converting value to URIRef. Defaults to DEFAULT_NAMESPACE.
+    """
+
+    description: str = "Attaches a target property from a target node that is connected to a source node."
+
+    _query_template_use_case_a: str = """
+    SELECT ?sourceNode ?sourceProperty ?targetNode ?newSourceProperty ?newSourcePropertyValue WHERE {{
+        ?sourceNode ?sourceProperty ?targetNode .
+        BIND( <{target_property}> as ?newSourceProperty ) .
+        ?targetNode a <{target_node_type}> .
+        ?targetNode <{target_property}> ?newSourcePropertyValue . }}"""
+
+    _query_template_use_case_b: str = """
+    SELECT ?sourceNode ?sourceProperty ?targetNode ?newSourceProperty ?newSourcePropertyValue WHERE {{
+        ?sourceNode ?sourceProperty ?targetNode .
+        ?targetNode a <{target_node_type}> .
+        ?targetNode <{target_property_holding_new_property_name}> ?newSourceProperty .
+        ?targetNode <{target_property}> ?newSourcePropertyValue . }}"""
+
+    def __init__(
+        self,
+        target_node_type: URIRef,
+        target_property: URIRef,
+        target_property_holding_new_property: URIRef | None = None,
+        delete_target_node: bool = False,
+        convert_literal_to_uri: bool = False,
+        namespace: Namespace | None = None,
+    ):
+        self.target_node_type = target_node_type
+        self.target_property = target_property
+        self.delete_target_node = delete_target_node
+        self.target_property_holding_new_property = target_property_holding_new_property
+        self.convert_literal_to_uri = convert_literal_to_uri
+        self.namespace = namespace or DEFAULT_NAMESPACE
+
+    def transform(self, graph) -> None:
+        nodes_to_delete: list[tuple] = []
+
+        if self.target_property_holding_new_property is not None:
+            query = self._query_template_use_case_b.format(
+                target_node_type=self.target_node_type,
+                target_property_holding_new_property_name=self.target_property_holding_new_property,
+                target_property=self.target_property,
+            )
+        else:
+            query = self._query_template_use_case_a.format(
+                target_node_type=self.target_node_type,
+                target_property=self.target_property,
+            )
+
+        for (
+            source_node,
+            old_predicate,
+            target_node,
+            new_predicate_value,
+            new_property_value,
+        ) in graph.query(query):
+            if self.target_property_holding_new_property is not None:
+                # Ensure new predicate is URI compliant as we are creating a new predicate
+                new_predicate_value_string = sentence_or_string_to_camel(str(new_predicate_value))
+                predicate = as_neat_compliant_uri(self.namespace[new_predicate_value_string])
+            else:
+                predicate = old_predicate
+            # Create new connection from source node to value
+            graph.add(
+                (
+                    source_node,
+                    predicate,
+                    (self.namespace[new_property_value] if self.convert_literal_to_uri else new_property_value),
+                )
+            )
+            # Remove old relationship between source node and destination node
+            graph.remove((source_node, old_predicate, target_node))
+
+            nodes_to_delete.append(target_node)
+
+        if self.delete_target_node:
+            for target_node in nodes_to_delete:
+                # Remove triples with edges to target_node
+                graph.remove((None, None, target_node))
+                # Remove target node triple and its properties
+                graph.remove((target_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 nodes of specific rdf types that do not have any connection to them."
+    _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 type_ in self.node_prune_types:
+            for (subject,) in list(graph.query(self._query_template.format(rdf_type=type_))):  # type: ignore
+                graph.remove((subject, None, None))
+
+
+class PruneTypes(BaseTransformer):
+    """
+    Removes all the instances of specific type
+    """
+
+    description: str = "Prunes nodes of specific rdf types"
+    _query_template = """
+                        SELECT ?subject
+                        WHERE {{
+                            ?subject a <{rdf_type}> .
+                            }}
+                      """
+
+    def __init__(
+        self,
+        node_prune_types: list[URIRef],
+    ):
+        self.node_prune_types = node_prune_types
+
+    def transform(self, graph: Graph) -> None:
+        for type_ in self.node_prune_types:
+            for (subject,) in list(graph.query(self._query_template.format(rdf_type=type_))):  # type: ignore
+                graph.remove((subject, None, None))
+
+
+class PruneDeadEndEdges(BaseTransformer):
+    """
+    Removes all the triples where object is a node that is not found in graph
+    """
+
+    description: str = "Prunes the graph of specified rdf types that do not have connections to other nodes."
+    _query_template = """
+                        SELECT ?subject ?predicate ?object
+                        WHERE {
+                            ?subject ?predicate ?object .
+                            FILTER (isIRI(?object) && ?predicate != rdf:type)
+                            FILTER NOT EXISTS {?object ?p ?o .}
+
+                            }
+
+                      """
+
+    def transform(self, graph: Graph) -> None:
+        for triple in graph.query(self._query_template):
+            graph.remove(cast(Triple, triple))
+
+
+class PruneInstancesOfUnknownType(BaseTransformer):
+    """
+    Removes all the triples where object is a node that is not found in graph
+    """
+
+    description: str = "Prunes the graph of specified rdf types that do not have connections to other nodes."
+    _query_template = """
+                    SELECT DISTINCT ?subject
+                    WHERE {
+                        ?subject ?p ?o .
+                        FILTER NOT EXISTS {?subject a ?object .}
+
+                        }
+
+                    """
+
+    def transform(self, graph: Graph) -> None:
+        for (subject,) in graph.query(self._query_template):  # type: ignore
+            graph.remove((subject, None, None))