cognite-neat 0.86.0__py3-none-any.whl → 0.87.3__py3-none-any.whl

cognite/neat/rules/analysis/_information.py

@@ -0,0 +1,183 @@
+import logging
+import warnings
+from typing import Any, cast
+
+from pydantic import ValidationError
+from rdflib import URIRef
+
+from cognite.neat.rules.models import SchemaCompleteness
+from cognite.neat.rules.models._rdfpath import (
+    Hop,
+    RDFPath,
+    SelfReferenceProperty,
+    SingleProperty,
+)
+from cognite.neat.rules.models.entities import ClassEntity, ReferenceEntity
+from cognite.neat.rules.models.information import (
+    InformationClass,
+    InformationProperty,
+    InformationRules,
+)
+from cognite.neat.utils.rdf_ import get_inheritance_path
+
+from ._base import BaseAnalysis
+
+
+class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, InformationProperty, ClassEntity, str]):
+    """Assumes analysis over only the complete schema"""
+
+    def _get_object(self, property_: InformationProperty) -> ClassEntity | None:
+        return property_.value_type if isinstance(property_.value_type, ClassEntity) else None
+
+    def _get_max_occurrence(self, property_: InformationProperty) -> int | float | None:
+        return property_.max_count
+
+    def _get_reference(self, class_or_property: InformationClass | InformationProperty) -> ReferenceEntity | None:
+        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
+
+    def _get_cls_entity(self, class_: InformationClass | InformationProperty) -> ClassEntity:
+        return class_.class_
+
+    @classmethod
+    def _set_cls_entity(cls, property_: InformationProperty, class_: ClassEntity) -> None:
+        property_.class_ = class_
+
+    def _get_prop_entity(self, property_: InformationProperty) -> str:
+        return property_.property_
+
+    def _get_cls_parents(self, class_: InformationClass) -> list[ClassEntity] | None:
+        return list(class_.parent or []) or None
+
+    def _get_reference_rules(self) -> InformationRules | None:
+        return self.rules.reference
+
+    def _get_properties(self) -> list[InformationProperty]:
+        return list(self.rules.properties)
+
+    def _get_classes(self) -> list[InformationClass]:
+        return list(self.rules.classes)
+
+    def has_hop_transformations(self):
+        return any(
+            prop_.transformation and isinstance(prop_.transformation.traversal, Hop) for prop_ in self.rules.properties
+        )
+
+    def has_self_reference_property_transformations(self):
+        return any(
+            prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+            for prop_ in self.rules.properties
+        )
+
+    def all_reference_transformations(self):
+        return [
+            prop_
+            for prop_ in self.rules.properties
+            if prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+        ]
+
+    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str | URIRef, str]:
+        property_renaming_configuration: dict[str | URIRef, str] = {}
+
+        if definitions := self.class_property_pairs(only_rdfpath=True, consider_inheritance=True).get(class_, None):
+            for property_id, definition in definitions.items():
+                transformation = cast(RDFPath, definition.transformation)
+
+                # use case we have a single property rdf path, and defined prefix
+                # in either metadata or prefixes of rules
+                if isinstance(
+                    transformation.traversal,
+                    SingleProperty,
+                ) and (
+                    transformation.traversal.property.prefix in self.rules.prefixes
+                    or transformation.traversal.property.prefix == self.rules.metadata.prefix
+                ):
+                    namespace = (
+                        self.rules.metadata.namespace
+                        if transformation.traversal.property.prefix == self.rules.metadata.prefix
+                        else self.rules.prefixes[transformation.traversal.property.prefix]
+                    )
+
+                    property_renaming_configuration[namespace[transformation.traversal.property.suffix]] = property_id
+
+                # otherwise we default to the property id
+                else:
+                    property_renaming_configuration[property_id] = property_id
+
+        return property_renaming_configuration
+
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
+        """
+        Subset rules to only include desired classes and their properties.
+
+        Args:
+            desired_classes: Desired classes to include in the reduced data model
+
+        Returns:
+            Instance of InformationRules
+
+        !!! note "Inheritance"
+            If desired classes contain a class that is a subclass of another class(es), the parent class(es)
+            will be included in the reduced data model as well even though the parent class(es) are
+            not in the desired classes set. This is to ensure that the reduced data model is
+            consistent and complete.
+
+        !!! note "Partial Reduction"
+            This method does not perform checks if classes that are value types of desired classes
+            properties are part of desired classes. If a class is not part of desired classes, but it
+            is a value type of a property of a class that is part of desired classes, derived reduced
+            rules will be marked as partial.
+
+        !!! note "Validation"
+            This method will attempt to validate the reduced rules with custom validations.
+            If it fails, it will return a partial rules with a warning message, validated
+            only with base Pydantic validators.
+        """
+        if self.rules.metadata.schema_ is not SchemaCompleteness.complete:
+            raise ValueError("Rules are not complete cannot perform reduction!")
+        class_as_dict = self.as_class_dict()
+        class_parents_pairs = self.class_parent_pairs()
+        defined_classes = self.defined_classes(consider_inheritance=True)
+
+        possible_classes = defined_classes.intersection(desired_classes)
+        impossible_classes = desired_classes - possible_classes
+
+        # need to add all the parent classes of the desired classes to the possible classes
+        parents: set[ClassEntity] = set()
+        for class_ in possible_classes:
+            parents = parents.union({parent for parent in get_inheritance_path(class_, class_parents_pairs)})
+        possible_classes = possible_classes.union(parents)
+
+        if not possible_classes:
+            logging.error("None of the desired classes are defined in the data model!")
+            raise ValueError("None of the desired classes are defined in the data model!")
+
+        if impossible_classes:
+            logging.warning(f"Could not find the following classes defined in the data model: {impossible_classes}")
+            warnings.warn(
+                f"Could not find the following classes defined in the data model: {impossible_classes}",
+                stacklevel=2,
+            )
+
+        reduced_data_model: dict[str, Any] = {
+            "metadata": self.rules.metadata.model_copy(),
+            "prefixes": (self.rules.prefixes or {}).copy(),
+            "classes": [],
+            "properties": [],
+        }
+
+        logging.info(f"Reducing data model to only include the following classes: {possible_classes}")
+        for class_ in possible_classes:
+            reduced_data_model["classes"].append(class_as_dict[str(class_.suffix)])
+
+        class_property_pairs = self.classes_with_properties(consider_inheritance=False)
+
+        for class_, properties in class_property_pairs.items():
+            if class_ in possible_classes:
+                reduced_data_model["properties"].extend(properties)
+
+        try:
+            return type(self.rules)(**reduced_data_model)
+        except ValidationError as e:
+            warnings.warn(f"Reduced data model is not complete: {e}", stacklevel=2)
+            reduced_data_model["metadata"].schema_ = SchemaCompleteness.partial
+            return type(self.rules).model_construct(**reduced_data_model)

cognite/neat/rules/exporters/_rules2dms.py

@@ -20,7 +20,7 @@ from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
-from cognite.neat.utils.cdf_loaders import (
+from cognite.neat.utils.cdf.loaders import (
     ContainerLoader,
     DataModelingLoader,
     DataModelLoader,

cognite/neat/rules/exporters/_rules2ontology.py

@@ -10,7 +10,7 @@ from rdflib.collection import Collection as GraphCollection
 
 from cognite.neat.constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
 from cognite.neat.rules import exceptions
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -20,7 +20,8 @@ from cognite.neat.rules.models.information import (
     InformationProperty,
     InformationRules,
 )
-from cognite.neat.utils.utils import generate_exception_report, remove_namespace_from_uri
+from cognite.neat.utils.auxiliary import generate_exception_report
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExporter
 from ._validation import are_properties_redefined
@@ -109,11 +110,11 @@ class Ontology(OntologyModel):
         if rules.metadata.namespace is None:
             raise exceptions.MissingDataModelPrefixOrNamespace()
 
-        class_dict = InformationArchitectRulesAnalysis(rules).as_class_dict()
+        class_dict = InformationAnalysis(rules).as_class_dict()
         return cls(
             properties=[
                 OWLProperty.from_list_of_properties(definition, rules.metadata.namespace)
-                for definition in InformationArchitectRulesAnalysis(rules).as_property_dict().values()
+                for definition in InformationAnalysis(rules).as_property_dict().values()
             ],
             classes=[
                 OWLClass.from_class(definition, rules.metadata.namespace, rules.prefixes)
@@ -125,7 +126,7 @@ class Ontology(OntologyModel):
                     list(properties.values()),
                     rules.metadata.namespace,
                 )
-                for class_, properties in InformationArchitectRulesAnalysis(rules).class_property_pairs().items()
+                for class_, properties in InformationAnalysis(rules).class_property_pairs().items()
             ]
             + [
                 SHACLNodeShape.from_rules(

cognite/neat/rules/importers/_dms2rules.py

@@ -8,6 +8,7 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
+from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.views import (
     MultiEdgeConnectionApply,
     MultiReverseDirectRelationApply,
@@ -403,7 +404,8 @@ class DMSImporter(BaseImporter):
 
     def _get_is_list(self, prop: ViewPropertyApply) -> bool | None:
         if isinstance(prop, dm.MappedPropertyApply):
-            return self._container_prop_unsafe(prop).type.is_list
+            prop_type = self._container_prop_unsafe(prop).type
+            return isinstance(prop_type, ListablePropertyType) and prop_type.is_list
         elif isinstance(prop, MultiEdgeConnectionApply | MultiReverseDirectRelationApply):
             return True
         elif isinstance(prop, SingleEdgeConnectionApply | SingleReverseDirectRelationApply):

cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py

@@ -1,6 +1,5 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
-from typing import cast
 
 import cognite.neat.rules.issues.importing
 from cognite.neat.rules import issues
@@ -22,7 +21,7 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
 )
 from cognite.neat.rules.issues import IssueList, ValidationIssue
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
-from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity
+from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationClass, InformationProperty
 
 
@@ -89,12 +88,7 @@ class _DTDLConverter:
             name=item.display_name,
             description=item.description,
             comment=item.comment,
-            parent=[
-                cast(ParentClassEntity, parent_entity)
-                for parent in item.extends or []
-                if isinstance(parent_entity := ParentClassEntity.load(parent.as_class_id()), ParentClassEntity)
-            ]
-            or None,
+            parent=[parent.as_class_id() for parent in item.extends or []] or None,
         )
         self.classes.append(class_)
         for sub_item_or_id in item.contents or []:

cognite/neat/rules/importers/_inference2rules.py

@@ -7,7 +7,7 @@ from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
 import cognite.neat.rules.issues as issues
-from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
 from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
 from cognite.neat.rules.issues import IssueList
@@ -17,11 +17,7 @@ from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-from cognite.neat.utils.utils import (
-    get_namespace,
-    remove_namespace_from_uri,
-    uri_to_short_form,
-)
+from cognite.neat.utils.rdf_ import get_namespace, remove_namespace_from_uri, uri_to_short_form
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -204,7 +200,7 @@ class InferenceImporter(BaseImporter):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = PREFIXES.copy()
+        prefixes: dict[str, Namespace] = get_default_prefixes()
 
         query = INSTANCE_PROPERTIES_JSON_DEFINITION if self.check_for_json_string else INSTANCE_PROPERTIES_DEFINITION
         # Adds default namespace to prefixes

cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -5,7 +5,7 @@ import pandas as pd
 from rdflib import OWL, Graph
 
 from cognite.neat.rules.models._base import MatchType
-from cognite.neat.utils.utils import remove_namespace_from_uri
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 
 def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:

cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -9,7 +9,8 @@ from cognite.neat.rules.models._types._base import (
     PREFIX_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
 )
-from cognite.neat.utils.utils import convert_rdflib_content, remove_none_elements_from_set
+from cognite.neat.utils.collection_ import remove_none_elements_from_set
+from cognite.neat.utils.rdf_ import convert_rdflib_content
 
 
 def parse_owl_metadata(graph: Graph) -> dict:

cognite/neat/rules/importers/_owl2rules/_owl2properties.py

@@ -5,7 +5,7 @@ import pandas as pd
 from rdflib import Graph
 
 from cognite.neat.rules.models._base import MatchType
-from cognite.neat.utils.utils import remove_namespace_from_uri
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class
 

cognite/neat/rules/issues/spreadsheet.py

@@ -295,6 +295,41 @@ class ClassNoPropertiesNoParentError(NeatValidationError):
         return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class AssetRulesHaveCircularDependencyError(NeatValidationError):
+    description = "Asset rules have circular dependencies."
+    fix = "Linking between classes via property that maps to parent_external_id must yield hierarchy structure."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[tuple[str, str]]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        return f"Asset rules have circular dependencies between classes {', '.join(self.classes)}."
+
+
+@dataclass(frozen=True)
+class AssetParentPropertyPointsToDataValueTypeError(NeatValidationError):
+    description = "Parent property points to a data value type instead of a class."
+    fix = "Make sure that the parent property points to a class."
+
+    class_property_with_data_value_type: list[tuple[str, str]]
+
+    def dump(self) -> dict[str, list[tuple[str, str]]]:
+        output = super().dump()
+        output["class_property"] = self.class_property_with_data_value_type
+        return output
+
+    def message(self) -> str:
+        text = [
+            f"class {class_} property {property_}" for class_, property_ in self.class_property_with_data_value_type
+        ]
+        return f"Following  {', and'.join(text)} point to data value type instead to classes. This is a mistake."
+
+
 @dataclass(frozen=True)
 class ParentClassesNotDefinedError(NeatValidationError):
     description = "Parent classes are not defined."

cognite/neat/rules/models/_base.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import math
 import sys
 import types
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterator
 from functools import wraps
 from typing import Annotated, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
@@ -18,7 +18,6 @@ from pydantic import (
     BeforeValidator,
     ConfigDict,
     Field,
-    HttpUrl,
     PlainSerializer,
     constr,
     field_validator,
@@ -219,10 +218,6 @@ class RuleModel(BaseModel):
         return headers_by_sheet
 
 
-class URL(BaseModel):
-    url: HttpUrl
-
-
 class BaseMetadata(RuleModel):
     """
     Metadata model for data model
@@ -252,8 +247,13 @@ class BaseMetadata(RuleModel):
         """Returns a unique identifier for the metadata."""
         raise NotImplementedError()
 
+    @abstractmethod
+    def get_prefix(self) -> str:
+        """Returns the prefix for the metadata."""
+        raise NotImplementedError()
+
 
-class BaseRules(RuleModel):
+class BaseRules(RuleModel, ABC):
     """
     Rules is a core concept in `neat`. This represents fusion of data model
     definitions and (optionally) the transformation rules used to transform the data/graph

cognite/neat/rules/models/_rdfpath.py

@@ -232,21 +232,12 @@ class SingleProperty(Traversal):
         return f"{self.class_}({self.property})"
 
 
-class AllReferences(Traversal):
+class SelfReferenceProperty(Traversal):
     @classmethod
     def from_string(cls, class_: str) -> Self:
         return cls(class_=Entity.from_string(class_))
 
 
-class AllProperties(Traversal):
-    @classmethod
-    def from_string(cls, class_: str) -> Self:
-        return cls(class_=Entity.from_string(class_))
-
-    def __str__(self) -> str:
-        return f"{self.class_}(*)"
-
-
 class Origin(BaseModel):
     class_: Entity
 
@@ -290,7 +281,7 @@ class Query(BaseModel):
 
 
 class RDFPath(Rule):
-    traversal: SingleProperty | AllProperties | AllReferences | Hop
+    traversal: SingleProperty | SelfReferenceProperty | Hop
 
     def __str__(self) -> str:
         return f"{self.traversal}"
@@ -311,14 +302,13 @@ class SPARQLQuery(RDFPath):
     traversal: Query
 
 
-def parse_traversal(raw: str) -> AllReferences | AllProperties | SingleProperty | Hop:
+def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
     if result := CLASS_ID_REGEX_COMPILED.match(raw):
-        return AllReferences.from_string(class_=result.group(EntityTypes.class_))
-    elif result := ALL_PROPERTIES_REGEX_COMPILED.match(raw):
-        return AllProperties.from_string(class_=result.group(EntityTypes.class_))
+        return SelfReferenceProperty.from_string(class_=result.group(EntityTypes.class_))
     elif result := SINGLE_PROPERTY_REGEX_COMPILED.match(raw):
         return SingleProperty.from_string(
-            class_=result.group(EntityTypes.class_), property_=result.group(EntityTypes.property_)
+            class_=result.group(EntityTypes.class_),
+            property_=result.group(EntityTypes.property_),
         )
     elif result := HOP_REGEX_COMPILED.match(raw):
         return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
@@ -329,7 +319,9 @@ def parse_traversal(raw: str) -> AllReferences | AllProperties | SingleProperty
 def parse_table_lookup(raw: str) -> TableLookup:
     if result := TABLE_REGEX_COMPILED.match(raw):
         return TableLookup(
-            name=result.group(Lookup.table), key=result.group(Lookup.key), value=result.group(Lookup.value)
+            name=result.group(Lookup.table),
+            key=result.group(Lookup.key),
+            value=result.group(Lookup.value),
         )
     raise exceptions.NotValidTableLookUp(raw).to_pydantic_custom_error()
 
@@ -344,7 +336,10 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
             if Counter(rule_raw).get("|") != 1:
                 raise exceptions.NotValidRAWLookUp(rule_raw).to_pydantic_custom_error()
             traversal, table_lookup = rule_raw.split("|")
-            return RawLookup(traversal=parse_traversal(traversal), table=parse_table_lookup(table_lookup))
+            return RawLookup(
+                traversal=parse_traversal(traversal),
+                table=parse_table_lookup(table_lookup),
+            )
         case TransformationRuleType.sparql:
             return SPARQLQuery(traversal=Query(query=rule_raw))
         case None:
@@ -352,9 +347,10 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
 
 
 def is_valid_rule(rule_type: TransformationRuleType, rule_raw: str) -> bool:
-    is_valid_rule = {TransformationRuleType.rdfpath: is_rdfpath, TransformationRuleType.rawlookup: is_rawlookup}[
-        rule_type
-    ]
+    is_valid_rule = {
+        TransformationRuleType.rdfpath: is_rdfpath,
+        TransformationRuleType.rawlookup: is_rawlookup,
+    }[rule_type]
     return is_valid_rule(rule_raw)
 
 

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

@@ -5,7 +5,7 @@ from pydantic import Field, field_validator, model_validator
 from pydantic.main import IncEx
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.issues import MultiValueError
 from cognite.neat.rules import issues
 from cognite.neat.rules.models._base import BaseRules, RoleTypes, SheetList
@@ -14,7 +14,6 @@ from cognite.neat.rules.models.entities import (
     CdfResourceEntityList,
     ClassEntity,
     MultiValueTypeInfo,
-    ParentClassEntity,
     Undefined,
 )
 from cognite.neat.rules.models.information import (
@@ -61,14 +60,14 @@ class AssetProperty(InformationProperty):
         implementation: Details on how given class-property is implemented in the classic CDF
     """
 
-    implementation: CdfResourceEntityList | None = Field(alias="Implementation", default=None)
+    implementation: CdfResourceEntityList = Field(alias="Implementation")
 
 
 class AssetRules(BaseRules):
     metadata: AssetMetadata = Field(alias="Metadata")
     properties: SheetList[AssetProperty] = Field(alias="Properties")
     classes: SheetList[AssetClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes)
     last: "AssetRules | None" = Field(None, alias="Last")
     reference: "AssetRules | None" = Field(None, alias="Reference")
 
@@ -94,7 +93,7 @@ class AssetRules(BaseRules):
         # update parent classes
         for class_ in self.classes:
             if class_.parent:
-                for parent in cast(list[ParentClassEntity], class_.parent):
+                for parent in class_.parent:
                     if not isinstance(parent.prefix, str):
                         parent.prefix = self.metadata.prefix
             if class_.class_.prefix is Undefined:

cognite/neat/rules/models/asset/_validation.py

@@ -1,4 +1,41 @@
+from graphlib import CycleError
+from typing import cast
+
+from cognite.neat.rules import issues
+from cognite.neat.rules.issues.base import IssueList
+from cognite.neat.rules.models._base import SheetList
+from cognite.neat.rules.models.asset._rules import AssetProperty, AssetRules
+from cognite.neat.rules.models.entities import AssetEntity, AssetFields, ClassEntity
 from cognite.neat.rules.models.information._validation import InformationPostValidation
 
 
-class AssetPostValidation(InformationPostValidation): ...
+class AssetPostValidation(InformationPostValidation):
+    def validate(self) -> IssueList:
+        self.issue_list = super().validate()
+        self._parent_property_point_to_class()
+        self._circular_dependency()
+        return self.issue_list
+
+    def _parent_property_point_to_class(self) -> None:
+        class_property_with_data_value_type = []
+        for property_ in cast(SheetList[AssetProperty], self.properties):
+            for implementation in property_.implementation:
+                if (
+                    isinstance(implementation, AssetEntity)
+                    and implementation.property_ == AssetFields.parentExternalId
+                    and not isinstance(property_.value_type, ClassEntity)
+                ):
+                    class_property_with_data_value_type.append((property_.class_.suffix, property_.property_))
+
+        if class_property_with_data_value_type:
+            self.issue_list.append(
+                issues.spreadsheet.AssetParentPropertyPointsToDataValueTypeError(class_property_with_data_value_type)
+            )
+
+    def _circular_dependency(self) -> None:
+        from cognite.neat.rules.analysis import AssetAnalysis
+
+        try:
+            _ = AssetAnalysis(cast(AssetRules, self.rules)).class_topological_sort()
+        except CycleError as error:
+            self.issue_list.append(issues.spreadsheet.AssetRulesHaveCircularDependencyError(error.args[1]))

cognite/neat/rules/models/dms/_converter.py

@@ -11,7 +11,6 @@ from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
-    ParentClassEntity,
     ReferenceEntity,
     UnknownEntity,
     ViewEntity,
@@ -52,7 +51,7 @@ class _DMSRulesConverter:
                 description=view.description,
                 parent=[
                     # we do not want a version in class as we use URI for the class
-                    ParentClassEntity(prefix=implemented_view.prefix, suffix=implemented_view.suffix)
+                    implemented_view.as_class(skip_version=True)
                     # We only want parents in the same namespace, parent in a different namespace is a reference
                     for implemented_view in view.implements or []
                     if implemented_view.prefix == view.class_.prefix

cognite/neat/rules/models/dms/_exporter.py

@@ -5,6 +5,7 @@ from typing import Any, cast
 
 from cognite.client.data_classes import data_modeling as dm
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex
+from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.views import (
     SingleEdgeConnectionApply,
     SingleReverseDirectRelationApply,
@@ -23,7 +24,7 @@ from cognite.neat.rules.models.entities import (
     ViewPropertyEntity,
 )
 from cognite.neat.rules.models.wrapped_entities import DMSFilter, HasDataFilter, NodeTypeFilter
-from cognite.neat.utils.cdf_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
+from cognite.neat.utils.cdf.data_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
 
 from ._rules import DMSMetadata, DMSProperty, DMSRules, DMSView
 from ._schema import DMSSchema, PipelineSchema
@@ -282,8 +283,11 @@ class _DMSExporter:
                     type_cls = prop.value_type.dms
                 else:
                     type_cls = dm.DirectRelation
-
-                type_ = type_cls(is_list=prop.is_list or False)
+                type_: dm.PropertyType
+                if issubclass(type_cls, ListablePropertyType):
+                    type_ = type_cls(is_list=prop.is_list or False)
+                else:
+                    type_ = type_cls()
                 container.properties[prop.container_property] = dm.ContainerProperty(
                     type=type_,
                     nullable=prop.nullable if prop.nullable is not None else True,

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

@@ -165,6 +165,9 @@ class DMSMetadata(BaseMetadata):
             updated=datetime.now(),
         )
 
+    def get_prefix(self) -> str:
+        return self.space
+
 
 class DMSProperty(SheetEntity):
     view: ViewEntity = Field(alias="View")