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

cognite/neat/_graph/queries/_base.py

@@ -1,8 +1,9 @@
+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
@@ -27,9 +28,8 @@ class Queries:
         """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 .
@@ -37,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]:
@@ -73,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
 
@@ -82,41 +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)))
+        query = "SELECT DISTINCT ?subject"
+        if class_uri:
+            query += f" WHERE {{ ?subject a <{class_uri}> .}}"
+        else:
+            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
@@ -168,7 +179,8 @@ class Queries:
         instance_type: URIRef | None = None,
         property_renaming_config: dict | 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:
@@ -176,13 +188,13 @@ 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)
             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 [
                 "",
@@ -205,29 +217,37 @@ 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(
-                        remove_namespace_from_uri(instance_type, validation="prefix") if instance_type else value
+                        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:
@@ -327,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
@@ -359,6 +379,80 @@ class Queries:
         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]]:

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/_issues/_factory.py

@@ -35,7 +35,15 @@ def from_warning(warning: WarningMessage) -> NeatWarning:
 def _from_pydantic_error(error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead]) -> NeatError:
     neat_error = _create_neat_value_error(error)
     location = error["loc"]
-    return SpreadsheetError.create(location, neat_error, read_info_by_sheet.get(cast(str, location[0])))
+
+    # only errors caused in model_validate will have location information
+    if location:
+        return SpreadsheetError.create(location, neat_error, read_info_by_sheet.get(cast(str, location[0])))
+
+    # errors that occur while for example parsing spreadsheet in input rules
+    # will not have location information so we return neat_error as is
+    # this is workaround until more elegant solution is found
+    return neat_error
 
 
 def _create_neat_value_error(error: ErrorDetails) -> NeatValueError:

cognite/neat/_issues/errors/__init__.py

@@ -3,6 +3,7 @@ from cognite.neat._issues._base import NeatError, _get_subclasses
 from ._external import (
     AuthorizationError,
     CDFMissingClientError,
+    CDFMissingResourcesError,
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
@@ -45,6 +46,7 @@ from ._wrapper import (
 __all__ = [
     "AuthorizationError",
     "CDFMissingClientError",
+    "CDFMissingResourcesError",
     "ClassValueError",
     "ContainerValueError",
     "EnumValueError",

cognite/neat/_issues/errors/_external.py

@@ -80,3 +80,10 @@ class CDFMissingClientError(NeatError, RuntimeError):
     """CDF client is required: {reason}"""
 
     reason: str
+
+
+@dataclass(unsafe_hash=True)
+class CDFMissingResourcesError(NeatError, RuntimeError):
+    """Following CDF resources are missing: {resources}"""
+
+    resources: str

cognite/neat/_issues/warnings/user_modeling.py

@@ -20,9 +20,21 @@ __all__ = [
     "NodeTypeFilterOnParentViewWarning",
     "NotNeatSupportedFilterWarning",
     "ParentInDifferentSpaceWarning",
+    "ViewsAndDataModelNotInSameSpaceWarning",
 ]
 
 
+@dataclass(unsafe_hash=True)
+class ViewsAndDataModelNotInSameSpaceWarning(UserModelingWarning):
+    """The data model is in {data_model_space}, while views are in {views_spaces} space(s).
+    This is strongly discouraged as it can lead to confusion and unnecessary complexity.
+    """
+
+    fix = "Ensure that views and data model are in the same space and have same version"
+    data_model_space: str
+    views_spaces: str
+
+
 @dataclass(unsafe_hash=True)
 class DirectRelationMissingSourceWarning(UserModelingWarning):
     """The view {view_id}.{prop_name} is a direct relation without a source.

cognite/neat/_rules/_constants.py

@@ -117,6 +117,9 @@ SPLIT_ON_COMMA_PATTERN = re.compile(r",(?![^(]*\))")
 # This pattern ignores equal signs inside brackets
 SPLIT_ON_EQUAL_PATTERN = re.compile(r"=(?![^(]*\))")
 
+# Very special Edge Entity parsing
+SPLIT_ON_EDGE_ENTITY_ARGS_PATTERN = re.compile(r"(\btype\b|\bproperties\b|\bdirection\b)\s*=\s*([^,]+)")
+
 
 class _Patterns:
     @cached_property

cognite/neat/_rules/analysis/_base.py

@@ -487,43 +487,26 @@ class RulesAnalysis:
 
         rules = self.dms
 
-        # Views with properties or used as ValueType
-        # If a view is not used in properties or as ValueType, it is not added to the graph
-        # as we typically do not have the properties for it.
-        used_views = {prop_.view for prop_ in rules.properties} | {
-            prop_.value_type for prop_ in rules.properties if isinstance(prop_.value_type, ViewEntity)
-        }
-
         # Add nodes and edges from Views sheet
         for view in rules.views:
-            if view.view not in used_views:
-                continue
-            # if possible use human-readable label coming from the view name
-            if not di_graph.has_node(view.view.suffix):
-                di_graph.add_node(view.view.suffix, label=view.view.suffix)
-
-                if format == "implements" and view.implements:
-                    for implement in view.implements:
-                        if not di_graph.has_node(implement.suffix):
-                            di_graph.add_node(implement.suffix, label=implement.suffix)
-
-                        di_graph.add_edge(
-                            view.view.suffix,
-                            implement.suffix,
-                            label="implements",
-                            dashes=True,
-                        )
+            di_graph.add_node(view.view.suffix, label=view.view.suffix)
+
+            if format == "implements" and view.implements:
+                for implement in view.implements:
+                    di_graph.add_node(implement.suffix, label=implement.suffix)
+                    di_graph.add_edge(
+                        view.view.suffix,
+                        implement.suffix,
+                        label="implements",
+                        dashes=True,
+                    )
 
         if format == "data-model":
             # Add nodes and edges from Properties sheet
             for prop_ in rules.properties:
                 if prop_.connection and isinstance(prop_.value_type, ViewEntity):
-                    if not di_graph.has_node(prop_.view.suffix):
-                        di_graph.add_node(prop_.view.suffix, label=prop_.view.suffix)
-
-                    if not di_graph.has_node(prop_.value_type.suffix):
-                        di_graph.add_node(prop_.value_type.suffix, label=prop_.value_type.suffix)
-
+                    di_graph.add_node(prop_.view.suffix, label=prop_.view.suffix)
+                    di_graph.add_node(prop_.value_type.suffix, label=prop_.value_type.suffix)
                     di_graph.add_edge(
                         prop_.view.suffix,
                         prop_.value_type.suffix,
@@ -541,32 +524,28 @@ class RulesAnalysis:
         # Add nodes and edges from Views sheet
         for class_ in rules.classes:
             # if possible use human readable label coming from the view name
-            if not di_graph.has_node(class_.class_.suffix):
-                di_graph.add_node(
-                    class_.class_.suffix,
-                    label=class_.name or class_.class_.suffix,
-                )
 
-                if format == "implements" and class_.implements:
-                    for parent in class_.implements:
-                        if not di_graph.has_node(parent.suffix):
-                            di_graph.add_node(parent.suffix, label=parent.suffix)
-                        di_graph.add_edge(
-                            class_.class_.suffix,
-                            parent.suffix,
-                            label="implements",
-                            dashes=True,
-                        )
+            di_graph.add_node(
+                class_.class_.suffix,
+                label=class_.name or class_.class_.suffix,
+            )
+
+            if format == "implements" and class_.implements:
+                for parent in class_.implements:
+                    di_graph.add_node(parent.suffix, label=parent.suffix)
+                    di_graph.add_edge(
+                        class_.class_.suffix,
+                        parent.suffix,
+                        label="implements",
+                        dashes=True,
+                    )
 
         if format == "data-model":
             # Add nodes and edges from Properties sheet
             for prop_ in rules.properties:
                 if isinstance(prop_.value_type, ClassEntity) and not isinstance(prop_.value_type, UnknownEntity):
-                    if not di_graph.has_node(prop_.class_.suffix):
-                        di_graph.add_node(prop_.class_.suffix, label=prop_.class_.suffix)
-
-                    if not di_graph.has_node(prop_.value_type.suffix):
-                        di_graph.add_node(prop_.value_type.suffix, label=prop_.value_type.suffix)
+                    di_graph.add_node(prop_.class_.suffix, label=prop_.class_.suffix)
+                    di_graph.add_node(prop_.value_type.suffix, label=prop_.value_type.suffix)
 
                     di_graph.add_edge(
                         prop_.class_.suffix,

cognite/neat/_rules/exporters/_rules2excel.py

@@ -55,7 +55,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     Style = Literal["none", "minimal", "default", "maximal"]
     DumpOptions = Literal["user", "last", "reference"]
     _main_header_by_sheet_name: ClassVar[dict[str, str]] = {
-        "Properties": "Definition of Properties per Class",
+        "Properties": "Definition of Properties",
         "Classes": "Definition of Classes",
         "Views": "Definition of Views",
         "Containers": "Definition of Containers",

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -10,6 +10,7 @@ from cognite.client import data_modeling as dm
 from rdflib import RDF, RDFS, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
+from cognite.neat._config import GLOBAL_CONFIG
 from cognite.neat._constants import NEAT, get_default_prefixes_and_namespaces
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
@@ -27,6 +28,7 @@ from cognite.neat._store import NeatGraphStore
 from cognite.neat._store._provenance import INSTANCES_ENTITY
 from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
+from cognite.neat._utils.text import NamingStandardization
 
 from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
 
@@ -403,7 +405,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
         else:
             existing_classes = {}
         classes: list[InformationInputClass] = []
-        properties_by_class_suffix_by_property_id_lowered: dict[str, dict[str, InformationInputProperty]] = {}
+        properties_by_class_suffix_by_property_id: dict[str, dict[str, InformationInputProperty]] = {}
 
         # Help for IDE
         type_uri: URIRef
@@ -455,7 +457,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
                         continue
                     property_id = remove_namespace_from_uri(property_uri)
                     self._add_uri_namespace_to_prefixes(property_uri, prefixes)
-                    if existing_prop := properties_by_id.get(property_id.casefold()):
+                    property_id_standardized = NamingStandardization.standardize_property_str(property_uri)
+                    if existing_prop := properties_by_id.get(property_id_standardized):
                         if not isinstance(existing_prop.instance_source, list):
                             existing_prop.instance_source = (
                                 [existing_prop.instance_source] if existing_prop.instance_source else []
@@ -463,29 +466,28 @@ class SubclassInferenceImporter(BaseRDFImporter):
                         existing_prop.instance_source.append(property_uri)
                         continue
                     else:
-                        properties_by_id[property_id.casefold()] = self._create_property(
+                        properties_by_id[property_id_standardized] = self._create_property(
                             read_properties, class_suffix, property_uri, property_id, prefixes
                         )
-                properties_by_class_suffix_by_property_id_lowered[class_suffix] = properties_by_id
+                properties_by_class_suffix_by_property_id[class_suffix] = properties_by_id
             if parent_suffix:
                 properties_by_id = {}
                 for property_uri, read_properties in shared_properties.items():
                     property_id = remove_namespace_from_uri(property_uri)
                     self._add_uri_namespace_to_prefixes(property_uri, prefixes)
-                    if existing_prop := properties_by_id.get(property_id.casefold()):
+                    property_id_standardized = NamingStandardization.standardize_property_str(property_uri)
+                    if existing_prop := properties_by_id.get(property_id_standardized):
                         if not isinstance(existing_prop.instance_source, list):
                             existing_prop.instance_source = (
                                 [existing_prop.instance_source] if existing_prop.instance_source else []
                             )
                         existing_prop.instance_source.append(property_uri)
                     else:
-                        properties_by_id[property_uri.casefold()] = self._create_property(
+                        properties_by_id[property_id_standardized] = self._create_property(
                             read_properties, parent_suffix, property_uri, property_id, prefixes
                         )
         return classes, [
-            prop
-            for properties in properties_by_class_suffix_by_property_id_lowered.values()
-            for prop in properties.values()
+            prop for properties in properties_by_class_suffix_by_property_id.values() for prop in properties.values()
         ]
 
     @staticmethod
@@ -522,7 +524,11 @@ class SubclassInferenceImporter(BaseRDFImporter):
             existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
         existing_class: InformationClass | None
-        for type_uri, instance_count in count_by_type.items():
+        total_instance_count = sum(count_by_type.values())
+        iterable = count_by_type.items()
+        if GLOBAL_CONFIG.use_iterate_bar_threshold and total_instance_count > GLOBAL_CONFIG.use_iterate_bar_threshold:
+            iterable = iterate_progress_bar(iterable, len(count_by_type), "Inferring types...")  # type: ignore[assignment]
+        for type_uri, instance_count in iterable:
             property_query = self._properties_query.format(type=type_uri, unknown_type=NEAT.UnknownType)
             class_suffix = remove_namespace_from_uri(type_uri)
             if (existing_class := existing_classes.get(class_suffix)) and existing_class.instance_source is None:

cognite/neat/_rules/models/_base_rules.py

@@ -126,7 +126,6 @@ class SchemaModel(BaseModel):
         extra="ignore",
         use_enum_values=True,
     )
-    validators_to_skip: set[str] = Field(default_factory=set, exclude=True)
 
     @classmethod
     def mandatory_fields(cls, use_alias=False) -> set[str]:
@@ -256,7 +255,6 @@ class BaseRules(SchemaModel, ABC):
 
     Args:
         metadata: Data model metadata
-        validators_to_skip: List of validators to skip. Defaults to []
     """
 
     metadata: BaseMetadata