cognite-neat 0.109.4__py3-none-any.whl → 0.111.0__py3-none-any.whl

cognite/neat/_graph/queries/_base.py

@@ -1,22 +1,17 @@
-import warnings
+import urllib.parse
 from collections import defaultdict
 from collections.abc import Iterable
-from typing import Literal, cast, overload
+from typing import Any, Literal, cast, overload
 
-from rdflib import RDF, Dataset, Graph, Namespace, URIRef
+from rdflib import RDF, XSD, Dataset, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 from rdflib.graph import DATASET_DEFAULT_GRAPH_ID
 from rdflib.query import ResultRow
 
 from cognite.neat._constants import NEAT
-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._shared import InstanceType
 from cognite.neat._utils.rdf_ import remove_instance_ids_in_batch, remove_namespace_from_uri
 
-from ._construct import build_construct_query
-
 
 class Queries:
     """Helper class for storing standard queries for the graph store."""
@@ -24,20 +19,17 @@ class Queries:
     def __init__(
         self,
         dataset: Dataset,
-        rules: dict[URIRef, InformationRules] | None = None,
         default_named_graph: URIRef | None = None,
     ):
         self.dataset = dataset
-        self.rules = rules or {}
         self.default_named_graph = default_named_graph or DATASET_DEFAULT_GRAPH_ID
 
     def graph(self, named_graph: URIRef | None = None) -> Graph:
         """Get named graph from the dataset to query over"""
         return self.dataset.graph(named_graph or self.default_named_graph)
 
-    def summarize_instances(self, named_graph: URIRef | None = None) -> list[tuple]:
+    def summarize_instances(self, named_graph: URIRef | None = None) -> list[tuple[str, int]]:
         """Summarize instances in the graph store by class and count"""
-
         query_statement = """ SELECT ?class (COUNT(?instance) AS ?instanceCount)
                              WHERE {
                              ?instance a ?class .
@@ -45,12 +37,12 @@ class Queries:
                              GROUP BY ?class
                              ORDER BY DESC(?instanceCount) """
 
-        return [
+        return [  # type: ignore[misc]
             (
-                remove_namespace_from_uri(cast(URIRef, cast(tuple, res)[0])),
-                cast(RdfLiteral, cast(tuple, res)[1]).value,
+                remove_namespace_from_uri(cast(URIRef, class_)),
+                cast(RdfLiteral, count).value,
             )
-            for res in list(self.graph(named_graph=named_graph).query(query_statement))
+            for class_, count in self.graph(named_graph=named_graph).query(query_statement)
         ]
 
     def types(self, named_graph: URIRef | None = None) -> dict[URIRef, str]:
@@ -81,6 +73,20 @@ class Queries:
             for (type_,) in list(self.graph(named_graph).query(query))
         }
 
+    def properties_by_type(self, named_graph: URIRef | None = None) -> dict[URIRef, dict[URIRef, str]]:
+        """Properties and their short form in the graph by type
+
+        Args:
+            named_graph: Named graph to query over, default None (default graph)
+
+        """
+        query = """SELECT DISTINCT ?type ?property
+               WHERE {?s a ?type . ?s ?property ?o . FILTER(?property != rdf:type)}"""
+        properties_by_type: dict[URIRef, dict[URIRef, str]] = defaultdict(dict)
+        for type_, property_ in cast(ResultRow, list(self.graph(named_graph).query(query))):
+            properties_by_type[type_][property_] = remove_namespace_from_uri(property_)  # type: ignore[index]
+        return properties_by_type
+
     def property_uri(self, property_: str, named_graph: URIRef | None = None) -> list[URIRef]:
         """Get the URIRef of a property
 
@@ -90,73 +96,38 @@ class Queries:
         """
         return [k for k, v in self.properties(named_graph).items() if v == property_]
 
-    def list_instances_ids_of_class(
+    @overload
+    def list_instances_ids(
+        self, class_uri: None = None, limit: int = -1, named_graph: URIRef | None = None
+    ) -> Iterable[tuple[URIRef, URIRef]]: ...
+
+    @overload
+    def list_instances_ids(
         self, class_uri: URIRef, limit: int = -1, named_graph: URIRef | None = None
-    ) -> list[URIRef]:
-        """Get instances ids for a given class
+    ) -> Iterable[URIRef]: ...
+
+    def list_instances_ids(
+        self, class_uri: URIRef | None = None, limit: int = -1, named_graph: URIRef | None = None
+    ) -> Iterable[URIRef] | Iterable[tuple[URIRef, URIRef]]:
+        """List all instance IDs
 
         Args:
-            class_uri: Class for which instances are to be found
+            class_uri: Class for which instances are to be found, default None (all instances)
             limit: Max number of instances to return, by default -1 meaning all instances
             named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             List of class instance URIs
         """
-        query_statement = "SELECT DISTINCT ?subject WHERE { ?subject a <class> .} LIMIT X".replace(
-            "class", class_uri
-        ).replace("LIMIT X", "" if limit == -1 else f"LIMIT {limit}")
-        return [cast(tuple, res)[0] for res in list(self.graph(named_graph).query(query_statement))]
-
-    def list_instances_of_type(self, class_uri: URIRef, named_graph: URIRef | None = None) -> list[ResultRow]:
-        """Get all triples for instances of a given class
-
-        Args:
-            class_uri: Class for which instances are to be found
-            named_graph: Named graph to query over, default None (default graph)
-
-        Returns:
-            List of triples for instances of the given class in the named graph
-        """
-        query = (
-            f"SELECT ?instance ?prop ?value "
-            f"WHERE {{ ?instance rdf:type <{class_uri}> . ?instance ?prop ?value . }} order by ?instance "
-        )
-
-        # Select queries gives an iterable of result rows
-        return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
-
-    def triples_of_type_instances(
-        self, rdf_type: str | URIRef, named_graph: URIRef | None = None
-    ) -> list[tuple[str, str, str]]:
-        """Get all triples of a given type.
-
-        Args:
-            rdf_type: Type URI to query
-            named_graph: Named graph to query over, default None (default graph)
-        """
-        named_graph = named_graph or self.default_named_graph
-        if isinstance(rdf_type, URIRef):
-            rdf_uri = rdf_type
-        elif isinstance(rdf_type, str) and self.rules and self.rules.get(named_graph):
-            rdf_uri = self.rules[named_graph].metadata.namespace[rdf_type]
+        query = "SELECT DISTINCT ?subject"
+        if class_uri:
+            query += f" WHERE {{ ?subject a <{class_uri}> .}}"
         else:
-            warnings.warn(
-                "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(named_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]
+            query += " ?type WHERE {{ ?subject a ?type .}}"
+        if limit != -1:
+            query += f" LIMIT {limit}"
+        # MyPy is not very happy with RDFLib, so just ignore the type hinting here
+        return (tuple(res) if class_uri is None else res[0] for res in self.graph(named_graph).query(query))  # type: ignore[index, return-value, arg-type]
 
     def type_with_property(self, type_: URIRef, property_uri: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a property exists in the graph store
@@ -205,26 +176,25 @@ class Queries:
     def describe(
         self,
         instance_id: URIRef,
-        instance_type: str | None = None,
+        instance_type: URIRef | None = None,
         property_renaming_config: dict | None = None,
-        property_types: dict[str, EntityTypes] | None = None,
         named_graph: URIRef | None = None,
-    ) -> tuple[str, dict[str | InstanceType, list[str]]] | None:
+        remove_uri_namespace: bool = True,
+    ) -> tuple[URIRef, dict[str | InstanceType, list[Any]]] | None:
         """DESCRIBE instance for a given class from the graph store
 
         Args:
             instance_id: Instance id for which we want to generate query
             instance_type: Type of the instance, default None (will be inferred from triples)
             property_renaming_config: Dictionary to rename properties, default None (no renaming)
-            property_types: Dictionary of property types, default None (helper for removal of namespace)
             named_graph: Named graph to query over, default None (default graph)
+            remove_uri_namespace: Whether to remove the namespace from the URI, by default True
 
 
         Returns:
             Dictionary of instance properties
         """
-        property_values: dict[str, list[str]] = defaultdict(list)
-        identifier = remove_namespace_from_uri(instance_id, validation="prefix")
+        property_values: dict[str, list[str] | list[URIRef]] = defaultdict(list)
         for _, predicate, object_ in cast(list[ResultRow], self.graph(named_graph).query(f"DESCRIBE <{instance_id}>")):
             if object_.lower() in [
                 "",
@@ -247,78 +217,42 @@ class Queries:
                 property_ = RDF.type
                 renamed_property_ = property_
 
-            if isinstance(object_, URIRef):
+            value: Any
+            if isinstance(object_, URIRef) and remove_uri_namespace:
+                # These properties contain the space in the Namespace.
                 value = remove_namespace_from_uri(object_, validation="prefix")
+            elif isinstance(object_, URIRef):
+                value = object_
             elif isinstance(object_, RdfLiteral):
-                value = object_.toPython()
+                if object_.datatype == XSD._NS["json"]:
+                    # For JSON literals, the .toPython() returns a Literal object.
+                    value = str(object_)
+                else:
+                    value = object_.toPython()
             else:
                 # It is a blank node
                 value = str(object_)
 
             # add type to the dictionary
             if predicate != RDF.type:
-                property_values[renamed_property_].append(value)
+                property_values[renamed_property_].append(value)  # type: ignore[arg-type]
             else:
                 # guarding against multiple rdf:type values as this is not allowed in CDF
                 if RDF.type not in property_values:
-                    property_values[RDF.type].append(instance_type if instance_type else value)
+                    property_values[RDF.type].append(
+                        remove_namespace_from_uri(instance_type, validation="prefix") if instance_type else value  # type: ignore[arg-type]
+                    )
                 else:
                     # we should not have multiple rdf:type values
                     continue
         if property_values:
             return (
-                identifier,
+                instance_id,
                 property_values,
             )
         else:
             return None
 
-    def construct_instances_of_class(
-        self,
-        class_: str,
-        properties_optional: bool = True,
-        instance_id: URIRef | None = None,
-        named_graph: URIRef | None = None,
-    ) -> list[tuple[str, str, str]]:
-        """CONSTRUCT instances for a given class from the graph store
-
-        Args:
-            class_: Class entity for which we want to generate query
-            properties_optional: Whether to make all properties optional, default True
-            instance_ids: List of instance ids to filter on, default None (all)
-            named_graph: Named graph to query over, default None (default graph
-
-        Returns:
-            List of triples for instances of the given class
-        """
-        named_graph = named_graph or self.default_named_graph
-        if (
-            self.rules
-            and self.rules.get(named_graph)
-            and (
-                query := build_construct_query(
-                    class_=ClassEntity(
-                        prefix=self.rules[named_graph].metadata.prefix,
-                        suffix=class_,
-                    ),
-                    graph=self.graph(named_graph),
-                    rules=self.rules[named_graph],
-                    properties_optional=properties_optional,
-                    instance_id=instance_id,
-                )
-            )
-        ):
-            result = self.graph(named_graph).query(query)
-
-            # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
-        else:
-            warnings.warn(
-                "No rules found for the graph store, returning empty list.",
-                stacklevel=2,
-            )
-            return []
-
     def list_triples(self, limit: int = 25, named_graph: URIRef | None = None) -> list[ResultRow]:
         """List triples in the graph store
 
@@ -346,7 +280,7 @@ class Queries:
     def list_types(
         self,
         remove_namespace: bool = False,
-        limit: int = 25,
+        limit: int | None = 25,
         named_graph: URIRef | None = None,
     ) -> list[ResultRow] | list[str]:
         """List types in the graph store
@@ -358,7 +292,9 @@ class Queries:
         Returns:
             List of types
         """
-        query = f"SELECT DISTINCT ?type WHERE {{ ?subject a ?type }} LIMIT {limit}"
+        query = "SELECT DISTINCT ?type WHERE { ?subject a ?type }"
+        if limit is not None:
+            query += f" LIMIT {limit}"
         result = cast(list[ResultRow], list(self.graph(named_graph).query(query)))
         if remove_namespace:
             return [remove_namespace_from_uri(res[0]) for res in result]
@@ -411,7 +347,7 @@ class Queries:
         """
         dropped_types: dict[URIRef, int] = {}
         for t in type_:
-            instance_ids = self.list_instances_ids_of_class(t)
+            instance_ids = list(self.list_instances_ids(t))
             dropped_types[t] = len(instance_ids)
             remove_instance_ids_in_batch(self.graph(named_graph), instance_ids)
         return dropped_types
@@ -438,3 +374,97 @@ class Queries:
             result[remove_namespace_from_uri(instance)] = remove_namespace_from_uri(types.split(","))
 
         return result
+
+    def count_of_type(self, class_uri: URIRef, named_graph: URIRef | None = None) -> int:
+        query = f"SELECT (COUNT(?instance) AS ?instanceCount) WHERE {{ ?instance a <{class_uri}> }}"
+        return int(next(iter(self.graph(named_graph).query(query)))[0])  # type: ignore[arg-type, index]
+
+    def types_with_instance_and_property_count(
+        self, remove_namespace: bool = True, named_graph: URIRef | None = None
+    ) -> list[dict[str, Any]]:
+        query = """
+        SELECT ?type (COUNT(DISTINCT ?instance) AS ?instanceCount) (COUNT(DISTINCT ?property) AS ?propertyCount)
+                WHERE {
+                  ?instance a ?type .
+                  ?instance ?property ?value .
+                  FILTER(?property != rdf:type)
+                }
+                GROUP BY ?type
+                ORDER BY DESC(?instanceCount)"""
+        return [
+            {
+                "type": urllib.parse.unquote(remove_namespace_from_uri(type_)) if remove_namespace else type_,
+                "instanceCount": cast(RdfLiteral, instance_count).toPython(),
+                "propertyCount": cast(RdfLiteral, property_count).toPython(),
+            }
+            for type_, instance_count, property_count in list(
+                cast(list[ResultRow], self.graph(named_graph).query(query))
+            )
+        ]
+
+    def properties_with_count(
+        self, remove_namespace: bool = True, named_graph: URIRef | None = None
+    ) -> list[dict[str, Any]]:
+        instance_count_by_type = {
+            entry["type"]: entry["instanceCount"]
+            for entry in self.types_with_instance_and_property_count(remove_namespace=False, named_graph=named_graph)
+        }
+        query = """SELECT ?type ?property (COUNT(DISTINCT ?instance) AS ?instanceCount)
+WHERE {
+  ?instance a ?type .
+  ?instance ?property ?value .
+  FILTER(?property != rdf:type)
+}
+GROUP BY ?type ?property
+ORDER BY ASC(?type) ASC(?property)"""
+        return [
+            {
+                "type": urllib.parse.unquote(remove_namespace_from_uri(type_)) if remove_namespace else type_,
+                "property": urllib.parse.unquote(remove_namespace_from_uri(property)) if remove_namespace else property,
+                "instanceCount": cast(RdfLiteral, instance_count).toPython(),
+                "total": instance_count_by_type[type_],
+            }
+            for type_, property, instance_count in list(cast(list[ResultRow], self.graph(named_graph).query(query)))
+        ]
+
+    @overload
+    def instances_with_properties(
+        self, type: URIRef, remove_namespace: Literal[False], named_graph: URIRef | None = None
+    ) -> dict[URIRef, set[URIRef]]: ...
+
+    @overload
+    def instances_with_properties(
+        self, type: URIRef, remove_namespace: Literal[True], named_graph: URIRef | None = None
+    ) -> dict[str, set[str]]: ...
+
+    def instances_with_properties(
+        self, type: URIRef, remove_namespace: bool = True, named_graph: URIRef | None = None
+    ) -> dict[str, set[str]] | dict[URIRef, set[URIRef]]:
+        query = """SELECT DISTINCT ?instance ?property
+WHERE {{
+    ?instance a <{type}> .
+    ?instance ?property ?value .
+    FILTER(?property != rdf:type)
+}}"""
+        result = defaultdict(set)
+        for instance, property_ in cast(Iterable[ResultRow], self.graph(named_graph).query(query.format(type=type))):
+            instance_str = urllib.parse.unquote(remove_namespace_from_uri(instance)) if remove_namespace else instance
+            property_str = urllib.parse.unquote(remove_namespace_from_uri(property_)) if remove_namespace else property_
+            result[instance_str].add(property_str)
+        return result
+
+    def list_instances_ids_by_space(
+        self, space_property: URIRef, named_graph: URIRef | None = None
+    ) -> Iterable[tuple[URIRef, str]]:
+        """Returns instance ids by space"""
+        query = f"""SELECT DISTINCT ?instance ?space
+                   WHERE {{?instance <{space_property}> ?space}}"""
+
+        for result in cast(Iterable[ResultRow], self.graph(named_graph).query(query)):
+            instance_id, space = cast(tuple[URIRef, URIRef | RdfLiteral], result)
+            if isinstance(space, URIRef):
+                yield instance_id, remove_namespace_from_uri(space)
+            elif isinstance(space, RdfLiteral):
+                yield instance_id, str(space.toPython())
+            else:
+                yield instance_id, str(space)

cognite/neat/_graph/transformers/__init__.py

@@ -16,12 +16,11 @@ from ._prune_graph import (
     PruneInstancesOfUnknownType,
     PruneTypes,
 )
-from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
+from ._rdfpath import MakeConnectionOnExactMatch
 from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SetType, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
-    "AddSelfReferenceProperty",
     "AssetEventConnector",
     "AssetFileConnector",
     "AssetRelationshipConnector",
@@ -49,7 +48,6 @@ Transformers = (
     | AssetFileConnector
     | AssetEventConnector
     | AssetRelationshipConnector
-    | AddSelfReferenceProperty
     | SplitMultiValueProperty
     | RelationshipAsEdgeTransformer
     | MakeConnectionOnExactMatch

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -240,50 +240,36 @@ class AssetRelationshipConnector(BaseTransformerStandardised):
             str(extractors.RelationshipsExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?source ?target WHERE {{
-                              <{relationship_id}> <{relationship_source_xid_prop}> ?source_xid .
-                              ?source <{asset_xid_property}> ?source_xid .
-                              ?source a <{asset_type}> .
-
-                              <{relationship_id}> <{relationship_target_xid_prop}> ?target_xid .
-                              ?target <{asset_xid_property}> ?target_xid .
-                              ?target a <{asset_type}> .}}"""
 
     def _count_query(self) -> str:
-        query = """SELECT (COUNT(?target) as ?count) WHERE {{
+        query = """SELECT (COUNT(?target_xid) as ?count) WHERE {{
                    ?relationship a <{relationship_type}> .
                    ?relationship <{relationship_source_xid_prop}> ?source_xid .
-                   ?source <{asset_xid_property}> ?source_xid .
-                   ?source a <{asset_type}> .
+                   ?source_xid a <{asset_type}> .
 
                    ?relationship <{relationship_target_xid_prop}> ?target_xid .
-                   ?target <{asset_xid_property}> ?target_xid .
-                   ?target a <{asset_type}> .}}"""
+                   ?target_xid a <{asset_type}> .}}"""
 
         return query.format(
             relationship_type=self.relationship_type,
             relationship_source_xid_prop=self.relationship_source_xid_prop,
             relationship_target_xid_prop=self.relationship_target_xid_prop,
-            asset_xid_property=self.asset_xid_property,
             asset_type=self.asset_type,
         )
 
     def _iterate_query(self) -> str:
-        query = """SELECT ?source ?relationship ?target WHERE {{
+        query = """SELECT ?source_xid ?relationship ?target_xid WHERE {{
                    ?relationship a <{relationship_type}> .
                    ?relationship <{relationship_source_xid_prop}> ?source_xid .
-                   ?source <{asset_xid_property}> ?source_xid .
-                   ?source a <{asset_type}> .
+                   ?source_xid a <{asset_type}> .
 
                    ?relationship <{relationship_target_xid_prop}> ?target_xid .
-                   ?target <{asset_xid_property}> ?target_xid .
-                   ?target a <{asset_type}> .}}"""
+                   ?target_xid a <{asset_type}> .}}"""
 
         return query.format(
             relationship_type=self.relationship_type,
             relationship_source_xid_prop=self.relationship_source_xid_prop,
             relationship_target_xid_prop=self.relationship_target_xid_prop,
-            asset_xid_property=self.asset_xid_property,
             asset_type=self.asset_type,
         )
 
@@ -293,13 +279,11 @@ class AssetRelationshipConnector(BaseTransformerStandardised):
         relationship_type: URIRef | None = None,
         relationship_source_xid_prop: URIRef | None = None,
         relationship_target_xid_prop: URIRef | None = None,
-        asset_xid_property: URIRef | None = None,
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
         self.relationship_type = relationship_type or DEFAULT_NAMESPACE.Relationship
         self.relationship_source_xid_prop = relationship_source_xid_prop or DEFAULT_NAMESPACE.sourceExternalId
         self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.targetExternalId
-        self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.externalId
 
     def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
         row_output = RowTransformationOutput()

cognite/neat/_graph/transformers/_rdfpath.py

@@ -1,59 +1,12 @@
 from typing import cast
 from urllib.parse import quote
 
-from rdflib import Graph, Namespace, URIRef
+from rdflib import Namespace, URIRef
 from rdflib.query import ResultRow
 
-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._utils.rdf_ import get_namespace, remove_namespace_from_uri
 
-from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
-
-
-class ReduceHopTraversal(BaseTransformer):
-    """ReduceHopTraversal is a transformer that reduces the number of hops to direct connection."""
-
-    ...
-
-
-# TODO: Standardise
-class AddSelfReferenceProperty(BaseTransformer):
-    description: str = "Adds property that contains id of reference to all references of given class in Rules"
-    _use_only_once: bool = True
-    _need_changes = frozenset({})
-    _ref_template: str = """SELECT ?s WHERE {{?s a <{type_}>}}"""
-
-    def __init__(
-        self,
-        rules: InformationRules,
-    ):
-        self.rules = rules
-        self.properties = InformationAnalysis(rules).all_reference_transformations()
-
-    def transform(self, graph: Graph) -> None:
-        for property_ in self.properties:
-            prefix = property_.instance_source.traversal.class_.prefix
-            suffix = property_.instance_source.traversal.class_.suffix
-
-            namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
-
-            for (reference,) in graph.query(self._ref_template.format(type_=namespace[suffix])):  # type: ignore [misc]
-                graph.add(
-                    (
-                        reference,
-                        self.rules.metadata.namespace[property_.property_],
-                        reference,
-                    )
-                )
-
-            traversal = SingleProperty.from_string(
-                class_=property_.view.id,
-                property_=f"{self.rules.metadata.prefix}:{property_.property_}",
-            )
-
-            property_.instance_source = RDFPath(traversal=traversal)
+from ._base import BaseTransformerStandardised, RowTransformationOutput
 
 
 class MakeConnectionOnExactMatch(BaseTransformerStandardised):

cognite/neat/_issues/__init__.py

@@ -2,24 +2,19 @@
 as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
-    DefaultWarning,
     IssueList,
     MultiValueError,
     NeatError,
     NeatIssue,
-    NeatIssueList,
     NeatWarning,
-    catch_issues,
-    catch_warnings,
 )
+from ._contextmanagers import catch_issues, catch_warnings
 
 __all__ = [
-    "DefaultWarning",
     "IssueList",
     "MultiValueError",
     "NeatError",
     "NeatIssue",
-    "NeatIssueList",
     "NeatWarning",
     "catch_issues",
     "catch_warnings",