cognite-neat 0.78.2__py3-none-any.whl → 0.78.4__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.78.2"
+__version__ = "0.78.4"

cognite/neat/graph/extractors/__init__.py

@@ -0,0 +1,4 @@
+from ._classic_cdf._asset_hierarchy import AssetHierarchyExtractor
+from ._mock_graph_generator import MockGraphGenerator
+
+__all__ = ["AssetHierarchyExtractor", "MockGraphGenerator"]

cognite/neat/graph/extractors/_classic_cdf/_asset_hierarchy.py

@@ -0,0 +1,100 @@
+from collections.abc import Iterable
+from datetime import datetime
+from pathlib import Path
+from typing import cast
+
+import pytz
+from cognite.client import CogniteClient
+from cognite.client.data_classes import Asset, AssetList
+from rdflib import RDF, Literal, Namespace
+
+from cognite.neat.constants import DEFAULT_NAMESPACE
+from cognite.neat.graph.extractors._base import BaseExtractor
+from cognite.neat.graph.models import Triple
+from cognite.neat.utils.utils import string_to_ideal_type
+
+
+class AssetHierarchyExtractor(BaseExtractor):
+    def __init__(
+        self,
+        assets: Iterable[Asset],
+        namespace: Namespace | None = None,
+    ):
+        self.namespace = namespace or DEFAULT_NAMESPACE
+        self.assets = assets
+
+    @classmethod
+    def from_dataset(
+        cls,
+        client: CogniteClient,
+        data_set_external_id: str,
+        namespace: Namespace | None = None,
+    ):
+        return cls(cast(Iterable[Asset], client.assets(data_set_external_ids=data_set_external_id)), namespace)
+
+    @classmethod
+    def from_hierarchy(cls, client: CogniteClient, root_asset_external_id: str, namespace: Namespace | None = None):
+        return cls(cast(Iterable[Asset], client.assets(asset_subtree_external_ids=root_asset_external_id)), namespace)
+
+    @classmethod
+    def from_file(cls, file_path: str, namespace: Namespace | None = None):
+        return cls(AssetList.load(Path(file_path).read_text()), namespace)
+
+    def extract(self) -> Iterable[Triple]:
+        """Extracts an asset with the given asset_id."""
+        for asset in self.assets:
+            yield from self._asset2triples(asset, self.namespace)
+
+    @classmethod
+    def _asset2triples(cls, asset: Asset, namespace: Namespace) -> list[Triple]:
+        """Converts an asset to triples."""
+        triples: list[Triple] = [(namespace[str(asset.id)], RDF.type, namespace["Asset"])]
+
+        if asset.name:
+            triples.append((namespace[str(asset.id)], namespace["name"], Literal(asset.name)))
+
+        if asset.description:
+            triples.append((namespace[str(asset.id)], namespace["description"], Literal(asset.description)))
+
+        if asset.external_id:
+            triples.append((namespace[str(asset.id)], namespace["externalId"], Literal(asset.external_id)))
+
+        if asset.source:
+            triples.append((namespace[str(asset.id)], namespace["source"], Literal(asset.source)))
+
+        # properties ref creation and update
+        triples.append(
+            (
+                namespace[str(asset.id)],
+                namespace["createdTime"],
+                Literal(datetime.fromtimestamp(asset.created_time / 1000, pytz.utc)),
+            )
+        )
+        triples.append(
+            (
+                namespace[str(asset.id)],
+                namespace["lastUpdatedTime"],
+                Literal(datetime.fromtimestamp(asset.last_updated_time / 1000, pytz.utc)),
+            )
+        )
+
+        if asset.parent_id:
+            triples.append((namespace[str(asset.id)], namespace["parent"], namespace[str(asset.parent_id)]))
+
+        if asset.root_id:
+            triples.append((namespace[str(asset.id)], namespace["root"], namespace[str(asset.root_id)]))
+
+        if asset.data_set_id:
+            triples.append((namespace[str(asset.id)], namespace["dataset"], namespace[str(asset.data_set_id)]))
+
+        if asset.labels:
+            for label in asset.labels:
+                # external_id can create ill-formed URIs, so we opt for Literal instead
+                triples.append((namespace[str(asset.id)], namespace["label"], Literal(label.dump()["externalId"])))
+
+        if asset.metadata:
+            for key, value in asset.metadata.items():
+                if value:
+                    triples.append((namespace[str(asset.id)], namespace[key], Literal(string_to_ideal_type(value))))
+
+        return triples

cognite/neat/rules/exporters/_rules2ontology.py

@@ -331,7 +331,7 @@ class OWLProperty(OntologyModel):
             elif isinstance(definition.value_type, ClassEntity):
                 owl_property.range_.add(namespace[str(definition.value_type.suffix)])
             else:
-                raise ValueError(f"Value type {definition.value_type} is not supported")
+                raise ValueError(f"Value type {definition.value_type.type_} is not supported")
             owl_property.domain.add(namespace[str(definition.class_.suffix)])
             owl_property.label.add(definition.name or definition.property_)
             if definition.description:
@@ -549,15 +549,19 @@ class SHACLPropertyShape(OntologyModel):
 
     @classmethod
     def from_property(cls, definition: InformationProperty, namespace: Namespace) -> "SHACLPropertyShape":
+        # TODO requires PR to fix MultiValueType and UnknownValueType
+        if isinstance(definition.value_type, ClassEntity):
+            expected_value_type = namespace[f"{definition.value_type.suffix}Shape"]
+        elif isinstance(definition.value_type, DataType):
+            expected_value_type = XSD[definition.value_type.xsd]
+        else:
+            raise ValueError(f"Value type {definition.value_type.type_} is not supported")
+
         return cls(
             id_=BNode(),
             path=namespace[definition.property_],
             node_kind=SHACL.IRI if definition.type_ == EntityTypes.object_property else SHACL.Literal,
-            expected_value_type=(
-                namespace[f"{definition.value_type.suffix}Shape"]
-                if isinstance(definition.value_type, ClassEntity)
-                else XSD[definition.value_type.xsd]
-            ),
+            expected_value_type=expected_value_type,
             min_count=definition.min_count,
             max_count=(
                 int(definition.max_count) if definition.max_count and definition.max_count != float("inf") else None

cognite/neat/rules/importers/_inference2rules.py

@@ -1,3 +1,4 @@
+import re
 from datetime import datetime
 from pathlib import Path
 from typing import Literal, cast, overload
@@ -12,12 +13,11 @@ from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issu
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models._base import MatchType
-from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-from cognite.neat.utils.utils import get_namespace, remove_namespace, replace_non_alphanumeric_with_underscore
+from cognite.neat.utils.utils import get_namespace, remove_namespace
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -39,29 +39,21 @@ class InferenceImporter(BaseImporter):
         issue_list: Issue list to store issues
         graph: Knowledge graph
         max_number_of_instance: Maximum number of instances to be used in inference
-        make_compliant: If True, NEAT will attempt to make the imported rules compliant with CDF
     """
 
-    def __init__(
-        self, issue_list: IssueList, graph: Graph, make_compliant: bool = False, max_number_of_instance: int = -1
-    ):
+    def __init__(self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1):
         self.issue_list = issue_list
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
-        self.make_compliant = make_compliant
 
     @classmethod
-    def from_graph_store(
-        cls, store: NeatGraphStoreBase, make_compliant: bool = False, max_number_of_instance: int = -1
-    ):
+    def from_graph_store(cls, store: NeatGraphStoreBase, max_number_of_instance: int = -1):
         issue_list = IssueList(title="Inferred from graph store")
 
-        return cls(
-            issue_list, store.graph, make_compliant=make_compliant, max_number_of_instance=max_number_of_instance
-        )
+        return cls(issue_list, store.graph, max_number_of_instance=max_number_of_instance)
 
     @classmethod
-    def from_rdf_file(cls, filepath: Path, make_compliant: bool = False, max_number_of_instance: int = -1):
+    def from_rdf_file(cls, filepath: Path, max_number_of_instance: int = -1):
         issue_list = IssueList(title=f"'{filepath.name}'")
 
         graph = Graph()
@@ -70,18 +62,18 @@ class InferenceImporter(BaseImporter):
         except Exception:
             issue_list.append(issues.fileread.FileReadError(filepath))
 
-        return cls(issue_list, graph, make_compliant=make_compliant, max_number_of_instance=max_number_of_instance)
+        return cls(issue_list, graph, max_number_of_instance=max_number_of_instance)
 
     @classmethod
-    def from_json_file(cls, filepath: Path, make_compliant: bool = False, max_number_of_instance: int = -1):
+    def from_json_file(cls, filepath: Path, max_number_of_instance: int = -1):
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @classmethod
-    def from_yaml_file(cls, filepath: Path, make_compliant: bool = False, max_number_of_instance: int = -1):
+    def from_yaml_file(cls, filepath: Path, max_number_of_instance: int = -1):
         raise NotImplementedError("YAML file format is not supported yet.")
 
     @classmethod
-    def from_xml_file(cls, filepath: Path, make_compliant: bool = False, max_number_of_instance: int = -1):
+    def from_xml_file(cls, filepath: Path, max_number_of_instance: int = -1):
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @overload
@@ -117,9 +109,6 @@ class InferenceImporter(BaseImporter):
         if future.result == "failure" or self.issue_list.has_errors:
             return self._return_or_raise(self.issue_list, errors)
 
-        if self.make_compliant and rules:
-            self._make_dms_compliant_rules(rules)
-
         return self._to_output(
             rules,
             self.issue_list,
@@ -155,7 +144,7 @@ class InferenceImporter(BaseImporter):
                 "class_": class_id,
                 "reference": class_uri,
                 "match_type": MatchType.exact,
-                "comment": f"Inferred from knowledge graph, where this class has {no_instances} instances",
+                "comment": f"Inferred from knowledge graph, where this class has <{no_instances}> instances",
             }
 
         # Infers all the properties of the class
@@ -179,7 +168,7 @@ class InferenceImporter(BaseImporter):
 
                     self._add_uri_namespace_to_prefixes(cast(URIRef, value_type_uri), prefixes)
                     value_type_id = remove_namespace(value_type_uri)
-                    id_ = f"{class_id}:{property_id}:{value_type_id}"
+                    id_ = f"{class_id}:{property_id}"
 
                     definition = {
                         "class_": class_id,
@@ -187,15 +176,41 @@ class InferenceImporter(BaseImporter):
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
+                        "comment": (
+                            f"Class <{class_id}> has property <{property_id}> with "
+                            f"value type <{value_type_id}> which occurs <1> times in the graph"
+                        ),
                     }
 
                     # USE CASE 1: If property is not present in properties
                     if id_ not in properties:
                         properties[id_] = definition
-                    # USE CASE 2: If property is present in properties but with different max count
-                    elif id_ in properties and not (properties[id_]["max_count"] == definition["max_count"]):
+
+                    # USE CASE 2: first time redefinition, value type change to multi
+                    elif id_ in properties and definition["value_type"] not in properties[id_]["value_type"]:
+                        properties[id_]["value_type"] = properties[id_]["value_type"] + " | " + definition["value_type"]
+                        properties[id_]["comment"] = (
+                            properties[id_]["comment"] + ", with" + definition["comment"].split("with")[1]
+                        )
+
+                    # USE CASE 3: existing but max count is different
+                    elif (
+                        id_ in properties
+                        and definition["value_type"] in properties[id_]["value_type"]
+                        and not (properties[id_]["max_count"] == definition["max_count"])
+                    ):
                         properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
 
+                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
+                            definition["value_type"], properties[id_]["comment"]
+                        )
+
+                    # USE CASE 4: Just update the comment with occurrence
+                    else:
+                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
+                            definition["value_type"], properties[id_]["comment"]
+                        )
+
         return {
             "metadata": self._default_metadata().model_dump(),
             "classes": list(classes.values()),
@@ -228,36 +243,17 @@ class InferenceImporter(BaseImporter):
         )
 
     @classmethod
-    def _make_dms_compliant_rules(cls, rules: InformationRules) -> None:
-        cls._fix_property_redefinition(rules)
-        cls._fix_naming_of_entities(rules)
-
-    @classmethod
-    def _fix_property_redefinition(cls, rules: InformationRules) -> None:
-        seen = set()
-        for i, property_ in enumerate(rules.properties.data):
-            prop_id = f"{property_.class_}.{property_.property_}"
-            if prop_id in seen:
-                property_.property_ = f"{property_.property_}_{i+1}"
-                seen.add(f"{property_.class_}.{property_.property_}")
-            else:
-                seen.add(prop_id)
+    def _update_value_type_occurrence_in_comment(cls, value_type: str, comment: str) -> str:
+        occurrence = cls._read_value_type_occurrence_from_comment(value_type, comment)
+        return comment.replace(
+            f"with value type <{value_type}> which occurs <{occurrence}> times in the graph",
+            f"with value type <{value_type}> which occurs <{occurrence+1}> times in the graph",
+        )
 
     @classmethod
-    def _fix_naming_of_entities(cls, rules: InformationRules) -> None:
-        # Fixing class ids
-        for class_ in rules.classes:
-            class_.class_ = class_.class_.as_dms_compliant_entity()
-            class_.parent = [parent.as_dms_compliant_entity() for parent in class_.parent] if class_.parent else None
-
-        # Fixing property definitions
-        for property_ in rules.properties:
-            # fix class id
-            property_.class_ = property_.class_.as_dms_compliant_entity()
-
-            # fix property id
-            property_.property_ = replace_non_alphanumeric_with_underscore(property_.property_)
-
-            # fix value type
-            if isinstance(property_.value_type, ClassEntity):
-                property_.value_type = property_.value_type.as_dms_compliant_entity()
+    def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
+        return int(
+            cast(
+                re.Match, re.search(rf"with value type <{value_type}> which occurs <(\d+)> times in the graph", comment)
+            ).group(1)
+        )

cognite/neat/rules/models/entities.py

@@ -5,8 +5,17 @@ from functools import total_ordering
 from typing import Annotated, Any, ClassVar, Generic, TypeVar, cast
 
 from cognite.client.data_classes.data_modeling.ids import ContainerId, DataModelId, NodeId, PropertyId, ViewId
-from pydantic import AnyHttpUrl, BaseModel, BeforeValidator, Field, PlainSerializer, model_serializer, model_validator
+from pydantic import (
+    AnyHttpUrl,
+    BaseModel,
+    BeforeValidator,
+    Field,
+    PlainSerializer,
+    model_serializer,
+    model_validator,
+)
 
+from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.utils.utils import replace_non_alphanumeric_with_underscore
 
 if sys.version_info >= (3, 11):
@@ -38,6 +47,7 @@ class EntityTypes(StrEnum):
     container = "container"
     datamodel = "datamodel"
     undefined = "undefined"
+    multi_value_type = "multi_value_type"
 
 
 # ALLOWED
@@ -58,6 +68,7 @@ _CLASS_ID_REGEX_COMPILED = re.compile(rf"^{_CLASS_ID_REGEX}$")
 _PROPERTY_ID_REGEX = rf"\((?P<{EntityTypes.property_}>{_ENTITY_ID_REGEX})\)"
 
 _ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>[^)]+)\))?$")
+_MULTI_VALUE_TYPE_PATTERN = re.compile(r"^(?P<types>.*?)(\((?P<content>[^)]+)\))?$")
 
 
 class _UndefinedType(BaseModel): ...
@@ -238,11 +249,6 @@ class ClassEntity(Entity):
         space = default_space if isinstance(self.prefix, _UndefinedType) else self.prefix
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
-    def as_dms_compliant_entity(self) -> "Self":
-        new_entity = self.model_copy(deep=True)
-        new_entity.suffix = replace_non_alphanumeric_with_underscore(new_entity.suffix)
-        return new_entity
-
 
 class ParentClassEntity(ClassEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.parent_class
@@ -264,6 +270,60 @@ class UnknownEntity(ClassEntity):
 T_ID = TypeVar("T_ID", bound=ContainerId | ViewId | DataModelId | PropertyId | NodeId | None)
 
 
+class MultiValueTypeInfo(BaseModel):
+    type_: ClassVar[EntityTypes] = EntityTypes.multi_value_type
+    types: list[DataType | ClassEntity]
+
+    def __str__(self) -> str:
+        return " | ".join([str(t) for t in self.types])
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
+
+    @classmethod
+    def load(cls, data: Any) -> "MultiValueTypeInfo":
+        # already instance of MultiValueTypeInfo
+        if isinstance(data, cls):
+            return data
+
+        # it is a raw string that needs to be parsed
+        elif isinstance(data, str):
+            return cls.model_validate({_PARSE: data})
+
+        # it is dict that needs to be parsed
+        else:
+            return cls.model_validate(data)
+
+    @model_validator(mode="before")
+    def _load(cls, data: Any) -> "dict | MultiValueTypeInfo":
+        if isinstance(data, dict) and _PARSE in data:
+            data = data[_PARSE]
+        elif isinstance(data, dict):
+            return data
+        else:
+            raise ValueError(f"Cannot load {cls.__name__} from {data}")
+
+        result = cls._parse(data)
+        return result
+
+    @classmethod
+    def _parse(cls, raw: str) -> dict:
+        if not (types := [type_.strip() for type_ in raw.split("|")]):
+            return {"types": [UnknownEntity()]}
+        else:
+            return {
+                "types": [
+                    DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_) for type_ in types
+                ]
+            }
+
+    def set_default_prefix(self, prefix: str):
+        for type_ in self.types:
+            if isinstance(type_, ClassEntity) and type_.prefix is Undefined:
+                type_.prefix = prefix
+
+
 class DMSEntity(Entity, Generic[T_ID], ABC):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str = Field(alias="space")
@@ -297,6 +357,11 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     def as_class(self) -> ClassEntity:
         return ClassEntity(prefix=self.space, suffix=self.external_id)
 
+    def as_dms_compliant_entity(self) -> "Self":
+        new_entity = self.model_copy(deep=True)
+        new_entity.suffix = replace_non_alphanumeric_with_underscore(new_entity.suffix)
+        return new_entity
+
 
 T_DMSEntity = TypeVar("T_DMSEntity", bound=DMSEntity)
 

cognite/neat/rules/models/information/_rules.py

@@ -44,6 +44,7 @@ from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     EntityTypes,
+    MultiValueTypeInfo,
     ParentClassEntity,
     ParentEntityList,
     ReferenceEntity,
@@ -162,7 +163,9 @@ class InformationProperty(SheetEntity):
     property_: PropertyType = Field(alias="Property")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
-    value_type: DataType | ClassEntity | UnknownEntity = Field(alias="Value Type", union_mode="left_to_right")
+    value_type: DataType | ClassEntity | MultiValueTypeInfo | UnknownEntity = Field(
+        alias="Value Type", union_mode="left_to_right"
+    )
     min_count: int | None = Field(alias="Min Count", default=None)
     max_count: int | float | None = Field(alias="Max Count", default=None)
     default: Any | None = Field(alias="Default", default=None)
@@ -277,6 +280,10 @@ class InformationRules(BaseRules):
         for property_ in self.properties:
             if isinstance(property_.value_type, ClassEntity) and property_.value_type.prefix is Undefined:
                 property_.value_type.prefix = self.metadata.prefix
+
+            if isinstance(property_.value_type, MultiValueTypeInfo):
+                property_.value_type.set_default_prefix(self.metadata.prefix)
+
             if property_.class_.prefix is Undefined:
                 property_.class_.prefix = self.metadata.prefix
 

cognite/neat/rules/models/information/_rules_input.py

@@ -7,7 +7,13 @@ from rdflib import Namespace
 
 from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness, _add_alias
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity, Unknown, UnknownEntity
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    MultiValueTypeInfo,
+    ParentClassEntity,
+    Unknown,
+    UnknownEntity,
+)
 
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
 
@@ -121,10 +127,15 @@ class InformationPropertyInput:
         )
 
     def dump(self, default_prefix: str) -> dict[str, Any]:
-        value_type: DataType | ClassEntity | UnknownEntity
+        value_type: MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity
 
         # property holding xsd data type
-        if DataType.is_data_type(self.value_type):
+        # check if it is multi value type
+        if "|" in self.value_type:
+            value_type = MultiValueTypeInfo.load(self.value_type)
+            value_type.set_default_prefix(default_prefix)
+
+        elif DataType.is_data_type(self.value_type):
             value_type = DataType.load(self.value_type)
 
         # unknown value type
@@ -257,6 +268,7 @@ class InformationRulesInput:
         elif isinstance(self.last, InformationRules):
             # We need to load through the InformationRulesInput to set the correct default space and version
             last = InformationRulesInput.load(self.last.model_dump()).dump()
+
         return dict(
             Metadata=self.metadata.dump(),
             Properties=[prop.dump(default_prefix) for prop in self.properties],

cognite/neat/utils/utils.py

@@ -355,3 +355,27 @@ def get_inheritance_path(child: Any, child_parent: dict[Any, list[Any]]) -> list
 
 def replace_non_alphanumeric_with_underscore(text):
     return re.sub(r"\W+", "_", text)
+
+
+def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | str:
+    try:
+        # Try converting to int
+        return int(input_string)
+    except ValueError:
+        try:
+            # Try converting to float
+            return float(input_string)  # type: ignore
+        except ValueError:
+            if input_string.lower() == "true":
+                # Return True if input is 'true'
+                return True
+            elif input_string.lower() == "false":
+                # Return False if input is 'false'
+                return False
+            else:
+                try:
+                    # Try converting to datetime
+                    return datetime.fromisoformat(input_string)  # type: ignore
+                except ValueError:
+                    # Return the input string if no conversion is possible
+                    return input_string

cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -276,16 +276,6 @@ class RulesInferenceFromRdfFile(Step):
             label="For what role Rules are intended?",
             options=["infer", *RoleTypes.__members__.keys()],
         ),
-        Configurable(
-            name="Make compliant",
-            value="True",
-            label=(
-                "Attempt to make the imported Rules compliant, by fixing "
-                "redefinition of properties and by making ids of entities compliant with"
-                " CDF-allowed set of characters ."
-            ),
-            options=["True", "False"],
-        ),
         Configurable(
             name="Maximum number of instances to process",
             value="-1",
@@ -302,7 +292,6 @@ class RulesInferenceFromRdfFile(Step):
 
         file_path = self.configs.get("File path", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
-        make_compliant = self.configs.get("Make compliant", "True") == "True"
 
         try:
             max_number_of_instance = int(self.configs.get("Maximum number of instances to process", -1))
@@ -325,7 +314,7 @@ class RulesInferenceFromRdfFile(Step):
             role_enum = RoleTypes[role]
 
         inference_importer = importers.InferenceImporter.from_rdf_file(
-            rdf_file_path, make_compliant=make_compliant, max_number_of_instance=max_number_of_instance
+            rdf_file_path, max_number_of_instance=max_number_of_instance
         )
         rules, issues = inference_importer.to_rules(errors="continue", role=role_enum)
 

{cognite_neat-0.78.2.dist-info → cognite_neat-0.78.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.78.2
+Version: 0.78.4
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

{cognite_neat-0.78.2.dist-info → cognite_neat-0.78.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-cognite/neat/_version.py,sha256=kWBpkJnZGsOhuJ5bhE96-VWCpvSaENAUiBvGF98dgWI,23
+cognite/neat/_version.py,sha256=4qUludpNixgmhGKESx2FYWVdHE0dHtestyzPDEVZ-iA,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -49,8 +49,10 @@ cognite/neat/graph/examples/Knowledge-Graph-Nordic44.xml,sha256=U2Ns-M4LRjT1fBkh
 cognite/neat/graph/examples/__init__.py,sha256=yAjHVY3b5jOjmbW-iLbhvu7BG014TpGi3K4igkDqW5I,368
 cognite/neat/graph/examples/skos-capturing-sheet-wind-topics.xlsx,sha256=CV_yK5ZSbYS_ktfIZUPD8Sevs47zpswLXQUDFkGE4Gw,45798
 cognite/neat/graph/exceptions.py,sha256=R6pyOH774n9w2x_X_nrUr8OMAdjJMf_XPIqAvxIQaWo,3401
-cognite/neat/graph/extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/graph/extractors/__init__.py,sha256=YpoCBdmRyn3Pjav2cAYBi5beEnyJBHu-jB7rh9XpgVE,182
 cognite/neat/graph/extractors/_base.py,sha256=TOXDnlqske8DgnJwA0THDVRgmR79Acjm56yF0E-2w7I,356
+cognite/neat/graph/extractors/_classic_cdf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/graph/extractors/_classic_cdf/_asset_hierarchy.py,sha256=p9jrHSxMsqPbkHBnstvktIF4lRgHvxpKvcgxY22YS2k,3851
 cognite/neat/graph/extractors/_mock_graph_generator.py,sha256=gziG2FFsLk-HmA9uxAeT9RCjVpFxjkCTLiC4tq2zgvw,14961
 cognite/neat/graph/models.py,sha256=AtLgZh2qyRP6NRetjQCy9qLMuTQB0CH52Zsev-qa2sk,149
 cognite/neat/graph/stores/__init__.py,sha256=ivvk7STSo-4wuP_CpizKUCPKmt_ufpNWRJUN9Bv5gdY,543
@@ -167,7 +169,7 @@ cognite/neat/rules/exporters/_base.py,sha256=m63iw8xjlZbZAxGL8mn7pjGf1pW3rVv8C20
 cognite/neat/rules/exporters/_models.py,sha256=vRd0P_YsrZ1eaAGGHfdTeFunaqHdaa0ZtnWiVZBR1nc,1976
 cognite/neat/rules/exporters/_rules2dms.py,sha256=US2IO4YTJSF_CDzau1dTpXyeHntJWVSPkMCQoUoKeC0,13688
 cognite/neat/rules/exporters/_rules2excel.py,sha256=HvUdXYHxfLMijYWdTnfqCsw3Izf8S-XDSve-2ZbqF8Y,14248
-cognite/neat/rules/exporters/_rules2ontology.py,sha256=NWS3cn2927LQqW_PdQ-92OLIlmIKGNk7xh5yOMAyj94,20120
+cognite/neat/rules/exporters/_rules2ontology.py,sha256=Od53uLdcC2Q7UiF5PA2P0gw3O14eTD3MeJ1-trd64ZM,20388
 cognite/neat/rules/exporters/_rules2yaml.py,sha256=GA8eUYRxUfIU6IMvlyGO5JidkOD5eUKSbH3qAiFiaCg,3026
 cognite/neat/rules/exporters/_validation.py,sha256=OlKIyf4nhSDehJwFHDQ8Zdf6HpNfW7dSe2s67eywHu4,4078
 cognite/neat/rules/importers/__init__.py,sha256=gR6_TAEa3iO5NCLKRztHg-FMiLdBnx47Z3iSzbwLfcE,481
@@ -178,7 +180,7 @@ cognite/neat/rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17g
 cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py,sha256=ysmWUxZ0npwrTB0uiH5jA0v37sfCwowGaYk17IyxPUU,12663
 cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py,sha256=QDyGt5YBaxzF4v_oCFSgKRSpwVdVruDU3-VW0DEiHbY,6718
 cognite/neat/rules/importers/_dtdl2rules/spec.py,sha256=tim_MfN1J0F3Oeqk3BMgIA82d_MZvhRuRMsLK3B4PYc,11897
-cognite/neat/rules/importers/_inference2rules.py,sha256=CFSwf8ZTg_luMooBaP3_0762fjDlJxCoxjLRm4J2_m4,11187
+cognite/neat/rules/importers/_inference2rules.py,sha256=JsV3Ii2wmgRELtpV0GC4Y1KtjhyyGR0dtEFpBonHoA8,11213
 cognite/neat/rules/importers/_owl2rules/__init__.py,sha256=tdGcrgtozdQyST-pTlxIa4cLBNTLvtk1nNYR4vOdFSw,63
 cognite/neat/rules/importers/_owl2rules/_owl2classes.py,sha256=QpTxvrTGczIa48X8lgXGnMN1AWPhHK0DR6uNq175xak,7357
 cognite/neat/rules/importers/_owl2rules/_owl2metadata.py,sha256=nwnUaBNAAYMoBre2UmsnkJXUuaqGEpR3U3txDrH2w6g,7527
@@ -210,11 +212,11 @@ cognite/neat/rules/models/dms/_schema.py,sha256=A4z8CINmLQgWzHoScxejRPMRo40ngKly
 cognite/neat/rules/models/dms/_serializer.py,sha256=iqp2zyyf8jEcU-R3PERuN8nu248xIqyxiWj4owAn92g,6406
 cognite/neat/rules/models/dms/_validation.py,sha256=nPSyfM1vGZ7d9Uv_2vF2HvMetygtehXW7eNtPD6eW8E,13937
 cognite/neat/rules/models/domain.py,sha256=tkKcHvDXnZ5IkOr1wHiuNBtE1h8OCFmf6GZSqzHzxjI,2814
-cognite/neat/rules/models/entities.py,sha256=qQIH93t2Vmyz-aqh-HWarQbenpmauPeECS9rkS6ihFM,16898
+cognite/neat/rules/models/entities.py,sha256=lkLsKg8U3Xto30PCB85ScDpv2SPRVq1ukVEQHzH53_g,18868
 cognite/neat/rules/models/information/__init__.py,sha256=HR6g8xgyU53U7Ck8pPdbT70817Q4NC1r1pCRq5SA8iw,291
 cognite/neat/rules/models/information/_converter.py,sha256=JN63_G5bygdL5WCz-q0_ygiU0NHkzUxm5mZ3WD8yUes,11029
-cognite/neat/rules/models/information/_rules.py,sha256=tdCjvAtqnFzEo2zcx-BZHmvjSs28gVun2wz8UaT-AOA,13268
-cognite/neat/rules/models/information/_rules_input.py,sha256=IZp_Wnrac0nVaHKth1YttWQOs-kULGKLMtngNQFY40A,10147
+cognite/neat/rules/models/information/_rules.py,sha256=bUzDzwFyWK9EH0FKCQPH9DCfKG3AUtBHaOshTW7VMRY,13476
+cognite/neat/rules/models/information/_rules_input.py,sha256=xmcQQl2vBYSG_IbxOwb6x4CdN3nIg_TY2-3RAeGDYic,10418
 cognite/neat/rules/models/information/_serializer.py,sha256=yti9I_xJruxrib66YIBInhze___Io-oPTQH6uWDumPE,3503
 cognite/neat/rules/models/information/_validation.py,sha256=Is2GzL2lZU3A5zPu3NjvlXfmIU2_Y10C5Nxi5Denz4g,7528
 cognite/neat/rules/models/wrapped_entities.py,sha256=ThhjnNNrpgz0HeORIQ8Q894trxP73P7T_TuZj6qH2CU,7157
@@ -230,7 +232,7 @@ cognite/neat/utils/cdf_loaders/data_classes.py,sha256=0apspfwVlFltYOZfmk_PNknS3Z
 cognite/neat/utils/exceptions.py,sha256=-w4cAcvcoWLf-_ZwAl7QV_NysfqtQzIOd1Ti-mpxJgM,981
 cognite/neat/utils/spreadsheet.py,sha256=LI0c7dlW0zXHkHw0NvB-gg6Df6cDcE3FbiaHBYLXdzQ,2714
 cognite/neat/utils/text.py,sha256=4bg1_Q0lg7KsoxaDOvXrVyeY78BJN8i-27BlyDzUCls,3082
-cognite/neat/utils/utils.py,sha256=gcbBbuUSm7xJhgU7ZRzeNc4eJtDVCS2CdNhbGP9gLq4,12919
+cognite/neat/utils/utils.py,sha256=OOuL0l-pv_8gDJCpXGBx-U9CEYDKQffP9dt8Dbg5kdU,13807
 cognite/neat/utils/xml.py,sha256=ppLT3lQKVp8wOP-m8-tFY8uB2P4R76l7R_-kUtsABng,992
 cognite/neat/workflows/__init__.py,sha256=oiKub_U9f5cA0I1nKl5dFkR4BD8_6Be9eMzQ_50PwP0,396
 cognite/neat/workflows/_exceptions.py,sha256=ugI_X1XNpikAiL8zIggBjcx6q7WvOpRIgvxHrj2Rhr4,1348
@@ -259,7 +261,7 @@ cognite/neat/workflows/steps/lib/current/graph_extractor.py,sha256=vW9UpJScx5dFV
 cognite/neat/workflows/steps/lib/current/graph_loader.py,sha256=HfGg1HRZhbV58TFu89FTjKeUxGsbCYLeFJIQFDN_pQM,2341
 cognite/neat/workflows/steps/lib/current/graph_store.py,sha256=r7VTxdaz8jJQU7FJbnRDMxvEYbSAZFNMABhPyfNwiFk,6295
 cognite/neat/workflows/steps/lib/current/rules_exporter.py,sha256=iFwzDWgUDBSPajaNAcXvu9pVw-jX66upvwyMXyTq7SE,23822
-cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=sZJv367gxLrF_ZrQrE8nibIEYh3N6JYiOjZ2MeBO1Cs,15190
+cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=QaGEVJ0JFoDbUt4YuJMQQrmL8jVubIzC077g4Wq9iCs,14697
 cognite/neat/workflows/steps/lib/current/rules_validator.py,sha256=LwF9lXlnuPOxDSsOMMTHBi2BHc5rk08IF5zahS9yQuw,4844
 cognite/neat/workflows/steps/lib/io/__init__.py,sha256=k7IPbIq3ey19oRc5sA_15F99-O6dxzqbm1LihGRRo5A,32
 cognite/neat/workflows/steps/lib/io/io_steps.py,sha256=QAGypoi1vP32BRiIgBZ0B4qsbFMcwhzpRiVUUnWysLA,16874
@@ -276,8 +278,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.78.2.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.78.2.dist-info/METADATA,sha256=iUWwZcRnmk4ccIsio_g3ktMvOuv2Bi6vdvoke6ERqys,9306
-cognite_neat-0.78.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.78.2.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.78.2.dist-info/RECORD,,
+cognite_neat-0.78.4.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.78.4.dist-info/METADATA,sha256=rCJxBd0usi6z7qKES5e_B3x6vTLxlXGQNraOAuXaOIs,9306
+cognite_neat-0.78.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.78.4.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.78.4.dist-info/RECORD,,