cognite-neat 0.78.1__tar.gz → 0.78.3__tar.gz

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/PKG-INFO

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

cognite_neat-0.78.3/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.78.3"

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/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-0.78.1 → cognite_neat-0.78.3}/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-0.78.1 → cognite_neat-0.78.3}/cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -8,19 +8,17 @@ from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 
-def parse_owl_classes(graph: Graph, make_compliant: bool = False, language: str = "en") -> list[dict]:
+def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
     """Parse owl classes from graph to pandas dataframe.
 
     Args:
         graph: Graph containing owl classes
-        make_compliant: Flag for generating compliant classes, by default False
         language: Language to use for parsing, by default "en"
 
     Returns:
         Dataframe containing owl classes
 
-    !!! note "make_compliant"
-        If `make_compliant` is set to True, in presence of errors, default values will be used instead.
+    !!! note "Compliant OWL classes"
         This makes the method very opinionated, but results in a compliant classes.
     """
 
@@ -48,8 +46,7 @@ def parse_owl_classes(graph: Graph, make_compliant: bool = False, language: str
     processed_df = _clean_up_classes(raw_df)
 
     # make compliant
-    if make_compliant:
-        processed_df = make_classes_compliant(processed_df)
+    processed_df = make_classes_compliant(processed_df)
 
     # Make Parent Class list elements into string joined with comma
     processed_df["Parent Class"] = processed_df["Parent Class"].apply(

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -12,18 +12,16 @@ from cognite.neat.rules.models._types._base import (
 from cognite.neat.utils.utils import convert_rdflib_content, remove_none_elements_from_set
 
 
-def parse_owl_metadata(graph: Graph, make_compliant: bool = False) -> dict:
+def parse_owl_metadata(graph: Graph) -> dict:
     """Parse owl metadata from graph to dict.
 
     Args:
         graph: Graph containing owl metadata
-        make_compliant: Flag for generating compliant metadata, by default False
 
     Returns:
         Dictionary containing owl metadata
 
-    !!! note "make_compliant"
-        If `make_compliant` is set to True, in presence of errors, default values will be used instead.
+    !!! note "Compliant OWL metadata"
         This makes the method very opinionated, but results in a compliant metadata.
 
 
@@ -72,10 +70,7 @@ def parse_owl_metadata(graph: Graph, make_compliant: bool = False) -> dict:
         }
     )
 
-    if make_compliant:
-        return make_metadata_compliant(raw_metadata)
-
-    return raw_metadata
+    return make_metadata_compliant(raw_metadata)
 
 
 def make_metadata_compliant(metadata: dict) -> dict:

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/cognite/neat/rules/importers/_owl2rules/_owl2properties.py

@@ -10,12 +10,11 @@ from cognite.neat.utils.utils import remove_namespace
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class
 
 
-def parse_owl_properties(graph: Graph, make_compliant: bool = False, language: str = "en") -> list[dict]:
+def parse_owl_properties(graph: Graph, language: str = "en") -> list[dict]:
     """Parse owl properties from graph to pandas dataframe.
 
     Args:
         graph: Graph containing owl properties
-        make_compliant: Flag for generating compliant properties, by default False
         language: Language to use for parsing, by default "en"
 
     Returns:
@@ -53,8 +52,7 @@ def parse_owl_properties(graph: Graph, make_compliant: bool = False, language: s
     processed_df = _clean_up_properties(raw_df)
 
     # make compliant
-    if make_compliant:
-        processed_df = make_properties_compliant(processed_df)
+    processed_df = make_properties_compliant(processed_df)
 
     # drop column _property_type, which was a helper column:
     processed_df.drop(columns=["_property_type"], inplace=True)

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/cognite/neat/rules/importers/_owl2rules/_owl2rules.py

@@ -21,25 +21,21 @@ class OWLImporter(BaseImporter):
 
         Args:
             filepath: Path to OWL ontology
-            make_compliant: If True, NEAT will attempt to make the imported rules compliant with CDF
 
     !!! Note
-        OWL Ontologies typically lacks some information that is required for making a complete
-        data model. This means that the methods .to_rules() will typically fail. Instead, it is recommended
-        that you use the .to_spreadsheet() method to generate an Excel file, and then manually add the missing
-        information to the Excel file. The Excel file can then be converted to a `Rules` object.
+        OWL Ontologies are information models which completeness varies. As such, constructing functional
+        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        values for missing information, attaching dangling properties to default containers based on the
+        property type, etc.
 
-        Alternatively, one can set the `make_compliant` parameter to True to allow neat to attempt to make
-        the imported rules compliant by adding default values for missing information, attaching dangling
-        properties to default containers based on the property type, etc. One has to be aware
-        that NEAT will be opinionated about how to make the ontology compliant, and that the resulting
-        rules may not be what you expect.
+        One has to be aware that NEAT will be opinionated about how to make the ontology
+        compliant, and that the resulting rules may not be what you expect.
 
     """
 
-    def __init__(self, filepath: Path, make_compliant: bool = False):
+    def __init__(self, filepath: Path):
         self.owl_filepath = filepath
-        self.make_compliant = make_compliant
 
     @overload
     def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
@@ -67,13 +63,12 @@ class OWLImporter(BaseImporter):
         graph.bind("skos", SKOS)
 
         components = {
-            "Metadata": parse_owl_metadata(graph, make_compliant=self.make_compliant),
-            "Classes": parse_owl_classes(graph, make_compliant=self.make_compliant),
-            "Properties": parse_owl_properties(graph, make_compliant=self.make_compliant),
+            "Metadata": parse_owl_metadata(graph),
+            "Classes": parse_owl_classes(graph),
+            "Properties": parse_owl_properties(graph),
         }
 
-        if self.make_compliant:
-            components = make_components_compliant(components)
+        components = make_components_compliant(components)
 
         rules = InformationRules.model_validate(components)
         return self._to_output(rules, IssueList(), errors, role)

{cognite_neat-0.78.1 → cognite_neat-0.78.3}/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-0.78.1 → cognite_neat-0.78.3}/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-0.78.1 → cognite_neat-0.78.3}/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-0.78.1 → cognite_neat-0.78.3}/cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -119,15 +119,6 @@ class OntologyToRules(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 converting "
-                "the information model provided in the ontology to data model."
-            ),
-            options=["True", "False"],
-        ),
     ]
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
@@ -136,7 +127,6 @@ class OntologyToRules(Step):
 
         file_name = self.configs.get("File name", 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"
 
         if file_name:
             rules_file_path = self.config.rules_store_path / file_name
@@ -152,7 +142,7 @@ class OntologyToRules(Step):
         if role != "infer" and role is not None:
             role_enum = RoleTypes[role]
 
-        ontology_importer = importers.OWLImporter(filepath=rules_file_path, make_compliant=make_compliant)
+        ontology_importer = importers.OWLImporter(filepath=rules_file_path)
         rules, issues = ontology_importer.to_rules(errors="continue", role=role_enum)
 
         if rules is None:
@@ -286,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",
@@ -312,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))
@@ -335,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.1 → cognite_neat-0.78.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.78.1"
+version = "0.78.3"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.78.1/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.78.1"