cognite-neat 0.107.0__py3-none-any.whl → 0.108.0__py3-none-any.whl

cognite/neat/_graph/queries/_base.py

@@ -3,11 +3,12 @@ from collections import defaultdict
 from collections.abc import Iterable
 from typing import Literal, cast, overload
 
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import RDF, 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 UNKNOWN_TYPE
+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
@@ -20,11 +21,21 @@ from ._construct import build_construct_query
 class Queries:
     """Helper class for storing standard queries for the graph store."""
 
-    def __init__(self, graph: Graph, rules: InformationRules | None = None):
-        self.graph = graph
-        self.rules = rules
-
-    def summarize_instances(self) -> list[tuple]:
+    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]:
         """Summarize instances in the graph store by class and count"""
 
         query_statement = """ SELECT ?class (COUNT(?instance) AS ?instanceCount)
@@ -39,36 +50,55 @@ class Queries:
                 remove_namespace_from_uri(cast(URIRef, cast(tuple, res)[0])),
                 cast(RdfLiteral, cast(tuple, res)[1]).value,
             )
-            for res in list(self.graph.query(query_statement))
+            for res in list(self.graph(named_graph=named_graph).query(query_statement))
         ]
 
-    @property
-    def types(self) -> dict[URIRef, str]:
+    def types(self, named_graph: URIRef | None = None) -> dict[URIRef, str]:
         """Types and their short form in the graph"""
         query = """SELECT DISTINCT ?type
                    WHERE {?s a ?type .}"""
-        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
 
-    def type_uri(self, type_: str) -> list[URIRef]:
+        return {  # type: ignore[misc, index, arg-type]
+            cast(URIRef, type_): remove_namespace_from_uri(cast(URIRef, type_))
+            for (type_,) in list(self.graph(named_graph).query(query))
+        }
+
+    def type_uri(self, type_: str, named_graph: URIRef | None = None) -> list[URIRef]:
         """Get the URIRef of a type"""
-        return [k for k, v in self.types.items() if v == type_]
+        return [k for k, v in self.types(named_graph).items() if v == type_]
+
+    def properties(self, named_graph: URIRef | None = None) -> dict[URIRef, str]:
+        """Properties and their short form in the graph
 
-    @property
-    def properties(self) -> dict[URIRef, str]:
+        Args:
+            named_graph: Named graph to query over, default None (default graph)
+
+        """
         query = """SELECT DISTINCT ?property
                WHERE {?s ?property ?o . FILTER(?property != rdf:type)}"""
-        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
+        return {  # type: ignore[misc, index, arg-type]
+            cast(URIRef, type_): remove_namespace_from_uri(cast(URIRef, type_))
+            for (type_,) in list(self.graph(named_graph).query(query))
+        }
 
-    def property_uri(self, property_: str) -> list[URIRef]:
-        """Get the URIRef of a type"""
-        return [k for k, v in self.properties.items() if v == property_]
+    def property_uri(self, property_: str, named_graph: URIRef | None = None) -> list[URIRef]:
+        """Get the URIRef of a property
 
-    def list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
+        Args:
+            property_: Property to find URIRef for
+            named_graph: Named graph to query over, default None (default graph)
+        """
+        return [k for k, v in self.properties(named_graph).items() if v == property_]
+
+    def list_instances_ids_of_class(
+        self, class_uri: URIRef, limit: int = -1, named_graph: URIRef | None = None
+    ) -> list[URIRef]:
         """Get instances ids for a given class
 
         Args:
             class_uri: Class for which instances are to be found
             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
@@ -76,16 +106,17 @@ class Queries:
         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.query(query_statement))]
+        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) -> list[ResultRow]:
+    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
+            List of triples for instances of the given class in the named graph
         """
         query = (
             f"SELECT ?instance ?prop ?value "
@@ -93,17 +124,22 @@ class Queries:
         )
 
         # Select queries gives an iterable of result rows
-        return cast(list[ResultRow], list(self.graph.query(query)))
+        return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
 
-    def triples_of_type_instances(self, rdf_type: str | URIRef) -> list[tuple[str, str, str]]:
+    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.
 
-        This method assumes the graph has been transformed into the default namespace.
+        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:
-            rdf_uri = self.rules.metadata.namespace[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]
         else:
             warnings.warn(
                 "Unknown namespace. Please either provide a URIRef or set the rules of the store.",
@@ -117,46 +153,50 @@ class Queries:
             "order by ?instance"
         )
 
-        result = self.graph.query(query)
+        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]
 
-    def type_with_property(self, type_: URIRef, property_uri: URIRef) -> bool:
+    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
 
         Args:
+            type_: Type URI to check
             property_uri: Property URI to check
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             True if property exists, False otherwise
         """
         query = f"SELECT ?o WHERE {{ ?s a <{type_}> ; <{property_uri}> ?o .}} Limit 1"
-        return bool(list(self.graph.query(query)))
+        return bool(list(self.graph(named_graph).query(query)))
 
-    def has_namespace(self, namespace: Namespace) -> bool:
+    def has_namespace(self, namespace: Namespace, named_graph: URIRef | None = None) -> bool:
         """Check if a namespace exists in the graph store
 
         Args:
             namespace: Namespace to check
+            named_graph: Named graph to query over, default None (default graph)
 
         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))
+        return bool(self.graph(named_graph).query(query))
 
-    def has_type(self, type_: URIRef) -> bool:
+    def has_type(self, type_: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a type exists in the graph store
 
         Args:
             type_: Type to check
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             True if type exists, False otherwise
         """
         query = f"ASK WHERE {{ ?s a <{type_}> }}"
-        return bool(self.graph.query(query))
+        return bool(self.graph(named_graph).query(query))
 
     def describe(
         self,
@@ -164,6 +204,7 @@ class Queries:
         instance_type: str | 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:
         """DESCRIBE instance for a given class from the graph store
 
@@ -172,6 +213,7 @@ class Queries:
             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)
 
 
         Returns:
@@ -179,7 +221,7 @@ class Queries:
         """
         property_values: dict[str, list[str]] = defaultdict(list)
         identifier = remove_namespace_from_uri(instance_id, validation="prefix")
-        for _, predicate, object_ in cast(list[ResultRow], self.graph.query(f"DESCRIBE <{instance_id}>")):
+        for _, predicate, object_ in cast(list[ResultRow], self.graph(named_graph).query(f"DESCRIBE <{instance_id}>")):
             if object_.lower() in [
                 "",
                 "none",
@@ -190,45 +232,28 @@ class Queries:
 
             # set property
             if property_renaming_config and predicate != RDF.type:
-                property_ = property_renaming_config.get(
-                    predicate, remove_namespace_from_uri(predicate, validation="prefix")
-                )
+                property_ = remove_namespace_from_uri(predicate, validation="prefix")
+                renamed_property_ = property_renaming_config.get(predicate, property_)
+
             elif not property_renaming_config and predicate != RDF.type:
                 property_ = remove_namespace_from_uri(predicate, validation="prefix")
+                renamed_property_ = property_
+
             else:
                 property_ = RDF.type
+                renamed_property_ = property_
 
-            # set value
-            # if it is URIRef and property type is object property, we need to remove namespace
-            # if it URIref but we are doing this into data type property, we do not remove namespace
-            # case 1 for RDF type we remove namespace
-            if property_ == RDF.type:
-                value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 2 for define object properties we remove namespace
-            elif (
-                isinstance(object_, URIRef)
-                and property_types
-                and (
-                    property_types.get(property_, None) == EntityTypes.object_property
-                    or property_types.get(property_, None) == EntityTypes.undefined
-                )
-            ):
+            if isinstance(object_, URIRef):
                 value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 3 when property type is not defined and returned value is URIRef we remove namespace
-            elif isinstance(object_, URIRef) and not property_types:
-                value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 4 for data type properties we do not remove namespace but keep the entire value
-            # but we drop the datatype part, and keep everything to be string (data loader will do the conversion)
-            # for value type it expects (if possible)
+            elif isinstance(object_, RdfLiteral):
+                value = object_.toPython()
             else:
+                # It is a blank node
                 value = str(object_)
 
             # add type to the dictionary
             if predicate != RDF.type:
-                property_values[property_].append(value)
+                property_values[renamed_property_].append(value)
             else:
                 # guarding against multiple rdf:type values as this is not allowed in CDF
                 if RDF.type not in property_values:
@@ -249,6 +274,7 @@ class Queries:
         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
 
@@ -256,21 +282,29 @@ class Queries:
             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
         """
-
-        if self.rules and (
-            query := build_construct_query(
-                class_=ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_),
-                graph=self.graph,
-                rules=self.rules,
-                properties_optional=properties_optional,
-                instance_id=instance_id,
+        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.query(query)
+            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]
@@ -281,25 +315,36 @@ class Queries:
             )
             return []
 
-    def list_triples(self, limit: int = 25) -> list[ResultRow]:
+    def list_triples(self, limit: int = 25, named_graph: URIRef | None = None) -> list[ResultRow]:
         """List triples in the graph store
 
         Args:
             limit: Max number of triples to return, by default 25
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             List of triples
         """
         query = f"SELECT ?subject ?predicate ?object WHERE {{ ?subject ?predicate ?object }} LIMIT {limit}"
-        return cast(list[ResultRow], list(self.graph.query(query)))
+        return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
 
     @overload
     def list_types(self, remove_namespace: Literal[False] = False, limit: int = 25) -> list[ResultRow]: ...
 
     @overload
-    def list_types(self, remove_namespace: Literal[True], limit: int = 25) -> list[str]: ...
+    def list_types(
+        self,
+        remove_namespace: Literal[True],
+        limit: int = 25,
+        named_graph: URIRef | None = None,
+    ) -> list[str]: ...
 
-    def list_types(self, remove_namespace: bool = False, limit: int = 25) -> list[ResultRow] | list[str]:
+    def list_types(
+        self,
+        remove_namespace: bool = False,
+        limit: int = 25,
+        named_graph: URIRef | None = None,
+    ) -> list[ResultRow] | list[str]:
         """List types in the graph store
 
         Args:
@@ -310,13 +355,14 @@ class Queries:
             List of types
         """
         query = f"SELECT DISTINCT ?type WHERE {{ ?subject a ?type }} LIMIT {limit}"
-        result = cast(list[ResultRow], list(self.graph.query(query)))
+        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]
         return result
 
     def multi_value_type_property(
         self,
+        named_graph: URIRef | None = None,
     ) -> Iterable[tuple[URIRef, URIRef, list[URIRef]]]:
         query = """SELECT ?sourceType ?property
                           (GROUP_CONCAT(DISTINCT STR(?valueType); SEPARATOR=",") AS ?valueTypes)
@@ -341,15 +387,20 @@ class Queries:
             value_types,
         ) in cast(
             ResultRow,
-            self.graph.query(query.format(unknownType=str(UNKNOWN_TYPE))),
+            self.graph(named_graph).query(query.format(unknownType=str(NEAT.UnknownType))),
         ):
             yield cast(URIRef, source_type), cast(URIRef, property_), [URIRef(uri) for uri in value_types.split(",")]
 
-    def drop_types(self, type_: list[URIRef]) -> dict[URIRef, int]:
+    def drop_types(
+        self,
+        type_: list[URIRef],
+        named_graph: URIRef | None = None,
+    ) -> dict[URIRef, int]:
         """Drop types from the graph store
 
         Args:
             type_: List of types to drop
+            named_graph: Named graph to query over, default None (default graph
 
         Returns:
             Dictionary of dropped types
@@ -358,11 +409,16 @@ class Queries:
         for t in type_:
             instance_ids = self.list_instances_ids_of_class(t)
             dropped_types[t] = len(instance_ids)
-            remove_instance_ids_in_batch(self.graph, instance_ids)
+            remove_instance_ids_in_batch(self.graph(named_graph), instance_ids)
         return dropped_types
 
-    def multi_type_instances(self) -> dict[str, list[str]]:
-        """Find instances with multiple types"""
+    def multi_type_instances(self, named_graph: URIRef | None = None) -> dict[str, list[str]]:
+        """Find instances with multiple types
+
+        Args:
+            named_graph: Named graph to query over, default None (default graph)
+
+        """
 
         query = """
         SELECT ?instance (GROUP_CONCAT(str(?type); SEPARATOR=",") AS ?types)
@@ -374,7 +430,7 @@ class Queries:
         """
 
         result = {}
-        for instance, types in self.graph.query(query):  # type: ignore
+        for instance, types in self.graph(named_graph).query(query):  # type: ignore
             result[remove_namespace_from_uri(instance)] = remove_namespace_from_uri(types.split(","))
 
         return result

cognite/neat/_graph/queries/_construct.py

@@ -115,7 +115,7 @@ def to_construct_triples(
         graph_template_triple = Triple(
             subject="?instance",
             predicate=f"{transformation.class_.prefix}:{transformation.property_}",
-            object=f'?{re.sub(r"[^_a-zA-Z0-9/_]", "_", str(transformation.property_).lower())}',
+            object=f"?{re.sub(r'[^_a-zA-Z0-9/_]', '_', str(transformation.property_).lower())}",
             optional=False,
         )
         templates.append(graph_template_triple)

cognite/neat/_graph/transformers/__init__.py

@@ -17,7 +17,7 @@ from ._prune_graph import (
     PruneTypes,
 )
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
-from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
+from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SetNeatType, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -38,6 +38,7 @@ __all__ = [
     "PruneInstancesOfUnknownType",
     "PruneTypes",
     "RelationshipAsEdgeTransformer",
+    "SetNeatType",
     "SplitMultiValueProperty",
 ]
 
@@ -62,4 +63,5 @@ Transformers = (
     | ConnectionToLiteral
     | BaseTransformerStandardised
     | LookupRelationshipSourceTarget
+    | SetNeatType
 )

cognite/neat/_graph/transformers/_value_type.py

@@ -4,10 +4,10 @@ from typing import Any, cast
 from urllib.parse import quote
 
 import rdflib
-from rdflib import RDF, Namespace, URIRef
+from rdflib import RDF, Literal, Namespace, URIRef
 from rdflib.query import ResultRow
 
-from cognite.neat._constants import UNKNOWN_TYPE
+from cognite.neat._constants import NEAT
 from cognite.neat._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat._utils.auxiliary import string_to_ideal_type
 from cognite.neat._utils.rdf_ import Triple, get_namespace, remove_namespace_from_uri
@@ -24,7 +24,7 @@ class SplitMultiValueProperty(BaseTransformerStandardised):
     _need_changes = frozenset({})
 
     def __init__(self, unknown_type: URIRef | None = None) -> None:
-        self.unknown_type = unknown_type or UNKNOWN_TYPE
+        self.unknown_type = unknown_type or NEAT.UnknownType
 
     def _iterate_query(self) -> str:
         query = """SELECT ?subjectType ?property
@@ -305,3 +305,54 @@ class ConnectionToLiteral(BaseTransformerStandardised):
         row_output.instances_modified_count += 1
 
         return row_output
+
+
+class SetNeatType(BaseTransformerStandardised):
+    description = "Set the sub type of an instance based on the property"
+
+    def __init__(
+        self, subject_type: URIRef, subject_predicate: URIRef, drop_property: bool, namespace: Namespace | None = None
+    ) -> None:
+        self.subject_type = subject_type
+        self.subject_predicate = subject_predicate
+        self.drop_property = drop_property
+        self._namespace = namespace or Namespace(get_namespace(subject_type))
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?object) AS ?objectCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isLiteral(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        query = """SELECT (COUNT(?object) AS ?objectCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isIRI(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _iterate_query(self) -> str:
+        query = """SELECT ?instance ?object
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?object
+                      FILTER(isLiteral(?object))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, object_literal = cast(tuple[URIRef, Literal], query_result_row)
+        if self.drop_property:
+            row_output.remove_triples.append((instance, self.subject_predicate, object_literal))
+
+        row_output.add_triples.append((instance, NEAT.type, self._namespace[str(object_literal.toPython())]))
+        row_output.instances_modified_count += 1
+
+        return row_output

cognite/neat/_issues/errors/_resources.py

@@ -30,7 +30,7 @@ class ResourceRetrievalError(ResourceError[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} does not exist"""
+    """The {resource_type} with identifier '{identifier}' does not exist"""
 
     extra = " This is expected by {referred_type} {referred_by}."
 

cognite/neat/_issues/warnings/__init__.py

@@ -31,7 +31,6 @@ from ._properties import (
     PropertyDirectRelationLimitWarning,
     PropertyNotFoundWarning,
     PropertyOverwritingWarning,
-    PropertySkippedWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
 )
@@ -68,7 +67,6 @@ __all__ = [
     "PropertyDirectRelationLimitWarning",
     "PropertyNotFoundWarning",
     "PropertyOverwritingWarning",
-    "PropertySkippedWarning",
     "PropertyTypeNotSupportedWarning",
     "PropertyValueTypeUndefinedWarning",
     "RegexViolationWarning",

cognite/neat/_issues/warnings/_models.py

@@ -74,7 +74,7 @@ class CDFNotSupportedWarning(NeatWarning, ABC):
 class NotSupportedViewContainerLimitWarning(CDFNotSupportedWarning):
     """The view {view_id} maps, {count} containers, which is more than the limit {limit}."""
 
-    fix = "Reduce the number of containers the view maps to." ""
+    fix = "Reduce the number of containers the view maps to."
 
     view_id: ViewId
     count: int

cognite/neat/_issues/warnings/_properties.py

@@ -65,14 +65,6 @@ class PropertyOverwritingWarning(PropertyWarning[T_Identifier]):
     overwriting: tuple[str, ...]
 
 
-@dataclass(unsafe_hash=True)
-class PropertySkippedWarning(PropertyWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} has a property {property_name}
-    which is skipped. {reason}."""
-
-    reason: str
-
-
 @dataclass(unsafe_hash=True)
 class PropertyDataTypeConversionWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} with identifier {identifier} failed to convert the property {property_name}: {error}"""

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -96,13 +96,13 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
 def _add_index_identifiers(workbook: Workbook, sheet: str, no_rows: int):
     """Adds index-based auto identifier to a sheet identifier column"""
     for i in range(no_rows):
-        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{i+1}")'
+        workbook[sheet][f"A{i + 2}"] = f'=IF(ISBLANK(B{i + 2}), "","{sheet}-{i + 1}")'
 
 
 def _add_uuid_identifiers(workbook: Workbook, sheet: str, no_rows: int):
     """Adds UUID-based auto identifier to a sheet identifier column"""
     for i in range(no_rows):
-        workbook[sheet][f"A{i+2}"] = f'=IF(ISBLANK(B{i+2}), "","{sheet}-{uuid.uuid4()}")'
+        workbook[sheet][f"A{i + 2}"] = f'=IF(ISBLANK(B{i + 2}), "","{sheet}-{uuid.uuid4()}")'
 
 
 def _add_drop_down_list(
@@ -122,7 +122,7 @@ def _add_drop_down_list(
     workbook[sheet].add_data_validation(drop_down_list)
 
     for i in range(no_rows):
-        drop_down_list.add(workbook[sheet][f"{column}{i+2}"])
+        drop_down_list.add(workbook[sheet][f"{column}{i + 2}"])
 
 
 def _adjust_column_width(workbook: Workbook):

cognite/neat/_rules/importers/__init__.py

@@ -1,7 +1,7 @@
 from ._base import BaseImporter
 from ._dms2rules import DMSImporter
 from ._dtdl2rules import DTDLImporter
-from ._rdf import IMFImporter, InferenceImporter, OWLImporter
+from ._rdf import IMFImporter, InferenceImporter, OWLImporter, SubclassInferenceImporter
 from ._spreadsheet2rules import ExcelImporter, GoogleSheetImporter
 from ._yaml2rules import YAMLImporter
 
@@ -14,6 +14,7 @@ __all__ = [
     "IMFImporter",
     "InferenceImporter",
     "OWLImporter",
+    "SubclassInferenceImporter",
     "YAMLImporter",
 ]
 
@@ -26,6 +27,7 @@ RulesImporters = (
     | DTDLImporter
     | YAMLImporter
     | InferenceImporter
+    | SubclassInferenceImporter
 )