cognite-neat 0.75.6__tar.gz → 0.75.8__tar.gz

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/PKG-INFO

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

cognite_neat-0.75.8/cognite/neat/_version.py

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

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -14,9 +14,10 @@ from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat.graph.models import Triple
 from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
 from cognite.neat.rules.models.rules import DMSRules, InformationRules
 from cognite.neat.rules.models.rules._information_rules import InformationProperty
-from cognite.neat.rules.models.rules._types import ClassEntity, EntityTypes, XSDValueType
 from cognite.neat.utils.utils import remove_namespace
 
 from ._base import BaseExtractor
@@ -55,7 +56,7 @@ class MockGraphGenerator(BaseExtractor):
             }
         elif all(isinstance(key, str) for key in class_count.keys()):
             self.class_count = {
-                ClassEntity.from_raw(f"{self.rules.metadata.prefix}:{key}"): value for key, value in class_count.items()
+                ClassEntity.load(f"{self.rules.metadata.prefix}:{key}"): value for key, value in class_count.items()
             }
         elif all(isinstance(key, ClassEntity) for key in class_count.keys()):
             self.class_count = cast(dict[ClassEntity, int], class_count)
@@ -147,7 +148,7 @@ def generate_triples(
     triples: list[Triple] = []
     for class_ in class_count:
         triples += [
-            (class_instance_id, RDF.type, URIRef(namespace[class_.suffix]))
+            (class_instance_id, RDF.type, URIRef(namespace[str(class_.suffix)]))
             for class_instance_id in instance_ids[class_]
         ]
 
@@ -246,7 +247,7 @@ def _remove_non_requested_sym_pairs(class_linkage: pd.DataFrame, class_count: di
 
 
 def _generate_mock_data_property_triples(
-    instance_ids: list[URIRef], property_: str, namespace: Namespace, value_type: XSDValueType
+    instance_ids: list[URIRef], property_: str, namespace: Namespace, value_type: DataType
 ) -> list[tuple[URIRef, URIRef, Literal]]:
     """Generates triples for data properties."""
 
@@ -338,7 +339,7 @@ def _generate_triples_per_class(
                 instance_ids[class_],
                 property_.property_,
                 namespace,
-                cast(XSDValueType, property_.value_type),
+                cast(DataType, property_.value_type),
             )
 
         elif property_.type_ == EntityTypes.object_property:

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/analysis/_base.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models.rules._types import ClassEntity
+from cognite.neat.rules.models.entities import ClassEntity
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/analysis/_information_rules.py

@@ -7,10 +7,10 @@ from typing import Any, cast
 import pandas as pd
 from pydantic import ValidationError
 
+from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
 from cognite.neat.rules.models.rdfpath import TransformationRuleType
 from cognite.neat.rules.models.rules._base import SchemaCompleteness
 from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty, InformationRules
-from cognite.neat.rules.models.rules._types._base import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
 from cognite.neat.utils.utils import get_inheritance_path
 
 from ._base import BaseAnalysis, DataModelingScenario
@@ -126,7 +126,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         return class_property_pairs
 
     def class_inheritance_path(self, class_: ClassEntity | str, use_reference: bool = False) -> list[ClassEntity]:
-        class_ = class_ if isinstance(class_, ClassEntity) else ClassEntity.from_raw(class_)
+        class_ = class_ if isinstance(class_, ClassEntity) else ClassEntity.load(class_)
         class_parent_pairs = self.class_parent_pairs(use_reference)
         return get_inheritance_path(class_, class_parent_pairs)
 
@@ -328,7 +328,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         """This is to simplify access to classes through dict."""
         class_dict: dict[str, InformationClass] = {}
         for definition in self.rules.classes:
-            class_dict[definition.class_.suffix] = definition
+            class_dict[str(definition.class_.suffix)] = definition
         return class_dict
 
     def subset_rules(self, desired_classes: set[ClassEntity], use_reference: bool = False) -> InformationRules:
@@ -398,7 +398,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         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[class_.suffix])
+            reduced_data_model["classes"].append(class_as_dict[str(class_.suffix)])
 
         class_property_pairs = self.classes_with_properties(consider_inheritance=False)
 

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/exporters/_models.py

@@ -30,6 +30,7 @@ class UploadResult(UploadResultCore):
     skipped: int = 0
     failed_created: int = 0
     failed_changed: int = 0
+    failed_deleted: int = 0
     error_messages: list[str] = field(default_factory=list)
 
     @property
@@ -38,7 +39,7 @@ class UploadResult(UploadResultCore):
 
     @property
     def failed(self) -> int:
-        return self.failed_created + self.failed_changed
+        return self.failed_created + self.failed_changed + self.failed_deleted
 
     def as_report_str(self) -> str:
         line = []
@@ -50,9 +51,13 @@ class UploadResult(UploadResultCore):
             line.append(f"skipped {self.skipped}")
         if self.unchanged:
             line.append(f"unchanged {self.unchanged}")
+        if self.deleted:
+            line.append(f"deleted {self.deleted}")
         if self.failed_created:
             line.append(f"failed to create {self.failed_created}")
         if self.failed_changed:
             line.append(f"failed to update {self.failed_changed}")
+        if self.failed_deleted:
+            line.append(f"failed to delete {self.failed_deleted}")
 
         return f"{self.name.title()}: {', '.join(line)}"

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/exporters/_rules2dms.py

@@ -151,21 +151,55 @@ class DMSExporter(CDFExporter[DMSSchema]):
             schema.frozen_ids.update(set(reference_schema.node_types.as_ids()))
         return schema
 
+    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
+        schema, to_export = self._prepare_schema_and_exporters(rules, client)
+
+        # we need to reverse order in which we are picking up the items to delete
+        # as they are sorted in the order of creation and we need to delete them in reverse order
+        for all_items, loader in reversed(to_export):
+            all_item_ids = loader.get_ids(all_items)
+            skipped = sum(1 for item_id in all_item_ids if item_id in schema.frozen_ids)
+            item_ids = [item_id for item_id in all_item_ids if item_id not in schema.frozen_ids]
+            cdf_items = loader.retrieve(item_ids)
+            cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
+            items = [item for item in all_items if loader.get_id(item) in item_ids]
+            to_delete = []
+
+            for item in items:
+                if (
+                    isinstance(loader, DataModelingLoader)
+                    and self.include_space is not None
+                    and not loader.in_space(item, self.include_space)
+                ):
+                    continue
+
+                cdf_item = cdf_item_by_id.get(loader.get_id(item))
+                if cdf_item:
+                    to_delete.append(cdf_item)
+
+            deleted = len(to_delete)
+            failed_deleted = 0
+
+            error_messages: list[str] = []
+            if not dry_run:
+                if to_delete:
+                    try:
+                        loader.delete(to_delete)
+                    except CogniteAPIError as e:
+                        failed_deleted = len(e.failed) + len(e.unknown)
+                        deleted -= failed_deleted
+                        error_messages.append(f"Failed delete: {e.message}")
+
+            yield UploadResult(
+                name=loader.resource_name,
+                deleted=deleted,
+                skipped=skipped,
+                failed_deleted=failed_deleted,
+                error_messages=error_messages,
+            )
+
     def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
-        schema = self.export(rules)
-        to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
-        if self.export_components.intersection({"all", "spaces"}):
-            to_export.append((schema.spaces, SpaceLoader(client)))
-        if self.export_components.intersection({"all", "containers"}):
-            to_export.append((schema.containers, ContainerLoader(client)))
-        if self.export_components.intersection({"all", "views"}):
-            to_export.append((schema.views, ViewLoader(client, self.existing_handling)))
-        if self.export_components.intersection({"all", "data_models"}):
-            to_export.append((schema.data_models, DataModelLoader(client)))
-        if isinstance(schema, PipelineSchema):
-            to_export.append((schema.databases, RawDatabaseLoader(client)))
-            to_export.append((schema.raw_tables, RawTableLoader(client)))
-            to_export.append((schema.transformations, TransformationLoader(client)))
+        schema, to_export = self._prepare_schema_and_exporters(rules, client)
 
         # The conversion from DMS to GraphQL does not seem to be triggered even if the views
         # are changed. This is a workaround to force the conversion.
@@ -254,3 +288,22 @@ class DMSExporter(CDFExporter[DMSSchema]):
 
             if loader.resource_name == "views" and (created or changed) and not redeploy_data_model:
                 redeploy_data_model = True
+
+    def _prepare_schema_and_exporters(
+        self, rules, client
+    ) -> tuple[DMSSchema, list[tuple[CogniteResourceList, ResourceLoader]]]:
+        schema = self.export(rules)
+        to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
+        if self.export_components.intersection({"all", "spaces"}):
+            to_export.append((schema.spaces, SpaceLoader(client)))
+        if self.export_components.intersection({"all", "containers"}):
+            to_export.append((schema.containers, ContainerLoader(client)))
+        if self.export_components.intersection({"all", "views"}):
+            to_export.append((schema.views, ViewLoader(client, self.existing_handling)))
+        if self.export_components.intersection({"all", "data_models"}):
+            to_export.append((schema.data_models, DataModelLoader(client)))
+        if isinstance(schema, PipelineSchema):
+            to_export.append((schema.databases, RawDatabaseLoader(client)))
+            to_export.append((schema.raw_tables, RawTableLoader(client)))
+            to_export.append((schema.transformations, TransformationLoader(client)))
+        return schema, to_export

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/exporters/_rules2ontology.py

@@ -11,6 +11,8 @@ 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.models.data_types import DataType
+from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
 from cognite.neat.rules.models.rules import DMSRules
 from cognite.neat.rules.models.rules._information_rules import (
     InformationClass,
@@ -18,7 +20,6 @@ from cognite.neat.rules.models.rules._information_rules import (
     InformationProperty,
     InformationRules,
 )
-from cognite.neat.rules.models.rules._types import XSD_VALUE_TYPE_MAPPINGS, EntityTypes
 from cognite.neat.utils.utils import generate_exception_report, remove_namespace
 
 from ._base import BaseExporter
@@ -114,7 +115,7 @@ class Ontology(OntologyModel):
             ],
             shapes=[
                 SHACLNodeShape.from_rules(
-                    class_dict[class_.suffix],
+                    class_dict[str(class_.suffix)],
                     list(properties.values()),
                     rules.metadata.namespace,
                 )
@@ -249,15 +250,15 @@ class OWLClass(OntologyModel):
             sub_class_of = []
             for parent_class in definition.parent:
                 try:
-                    sub_class_of.append(prefixes[parent_class.prefix][parent_class.suffix])
+                    sub_class_of.append(prefixes[str(parent_class.prefix)][str(parent_class.suffix)])
                 except KeyError:
-                    sub_class_of.append(namespace[parent_class.suffix])
+                    sub_class_of.append(namespace[str(parent_class.suffix)])
         else:
             sub_class_of = None
 
         return cls(
-            id_=namespace[definition.class_.suffix],
-            label=definition.name or definition.class_.suffix,
+            id_=namespace[str(definition.class_.suffix)],
+            label=definition.name or str(definition.class_.suffix),
             comment=definition.description,
             sub_class_of=sub_class_of,
             namespace=namespace,
@@ -324,12 +325,14 @@ class OWLProperty(OntologyModel):
         )
         for definition in definitions:
             owl_property.type_.add(OWL[definition.type_])
-            owl_property.range_.add(
-                XSD[definition.value_type.suffix]
-                if definition.value_type.suffix in XSD_VALUE_TYPE_MAPPINGS
-                else namespace[definition.value_type.suffix]
-            )
-            owl_property.domain.add(namespace[definition.class_.suffix])
+
+            if isinstance(definition.value_type, DataType):
+                owl_property.range_.add(XSD[definition.value_type.xsd])
+            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")
+            owl_property.domain.add(namespace[str(definition.class_.suffix)])
             owl_property.label.add(definition.name or definition.property_)
             if definition.description:
                 owl_property.comment.add(definition.description)
@@ -493,12 +496,12 @@ class SHACLNodeShape(OntologyModel):
         cls, class_definition: InformationClass, property_definitions: list[InformationProperty], namespace: Namespace
     ) -> "SHACLNodeShape":
         if class_definition.parent:
-            parent = [namespace[parent.suffix + "Shape"] for parent in class_definition.parent]
+            parent = [namespace[str(parent.suffix) + "Shape"] for parent in class_definition.parent]
         else:
             parent = None
         return cls(
-            id_=namespace[f"{class_definition.class_.suffix}Shape"],
-            target_class=namespace[class_definition.class_.suffix],
+            id_=namespace[f"{class_definition.class_.suffix!s}Shape"],
+            target_class=namespace[str(class_definition.class_.suffix)],
             parent=parent,
             property_shapes=[SHACLPropertyShape.from_property(prop, namespace) for prop in property_definitions],
             namespace=namespace,
@@ -552,8 +555,8 @@ class SHACLPropertyShape(OntologyModel):
             node_kind=SHACL.IRI if definition.type_ == EntityTypes.object_property else SHACL.Literal,
             expected_value_type=(
                 namespace[f"{definition.value_type.suffix}Shape"]
-                if definition.type_ == EntityTypes.object_property
-                else XSD[definition.value_type.suffix]
+                if isinstance(definition.value_type, ClassEntity)
+                else XSD[definition.value_type.xsd]
             ),
             min_count=definition.min_count,
             max_count=(

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/exporters/_validation.py

@@ -26,7 +26,7 @@ def are_entity_names_dms_compliant(
     flag: bool = True
     with warnings.catch_warnings(record=True) as validation_warnings:
         for class_ in rules.classes:
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, class_.class_.suffix):
+            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(class_.class_.suffix)):
                 warnings.warn(
                     exceptions.EntityIDNotDMSCompliant(
                         "Class", class_.class_.versioned_id, f"[Classes/Class/{class_.class_.versioned_id}]"
@@ -38,7 +38,7 @@ def are_entity_names_dms_compliant(
 
         for row, property_ in enumerate(rules.properties):
             # check class id which would resolve as view/container id
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, property_.class_.suffix):
+            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(property_.class_.suffix)):
                 warnings.warn(
                     exceptions.EntityIDNotDMSCompliant(
                         "Class", property_.class_.versioned_id, f"[Properties/Class/{row}]"

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_dms2rules.py

@@ -10,6 +10,14 @@ from cognite.client.utils import ms_to_datetime
 from cognite.neat.rules import issues
 from cognite.neat.rules.importers._base import BaseImporter, Rules
 from cognite.neat.rules.issues import IssueList
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    ContainerEntity,
+    DMSUnknownEntity,
+    ViewEntity,
+    ViewPropertyEntity,
+)
 from cognite.neat.rules.models.rules import DMSRules, DMSSchema, RoleTypes
 from cognite.neat.rules.models.rules._base import ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models.rules._dms_architect_rules import (
@@ -19,15 +27,6 @@ from cognite.neat.rules.models.rules._dms_architect_rules import (
     DMSView,
     SheetList,
 )
-from cognite.neat.rules.models.rules._types import (
-    ClassEntity,
-    ContainerEntity,
-    DMSValueType,
-    Undefined,
-    Unknown,
-    ViewEntity,
-    ViewPropEntity,
-)
 
 
 class DMSImporter(BaseImporter):
@@ -136,21 +135,21 @@ class DMSImporter(BaseImporter):
                             raise NotImplementedError(f"Constraint type {type(constraint_obj)} not implemented")
 
                     if isinstance(container_prop.type, dm.DirectRelation):
-                        direct_value_type: str | ViewEntity | DMSValueType
+                        direct_value_type: str | ViewEntity | DataType | DMSUnknownEntity
                         if prop.source is None:
                             issue_list.append(
                                 issues.importing.UnknownValueTypeWarning(class_entity.versioned_id, prop_id)
                             )
-                            direct_value_type = ViewPropEntity(prefix=Undefined, suffix=Unknown)
+                            direct_value_type = DMSUnknownEntity()
                         else:
-                            direct_value_type = ViewPropEntity.from_id(prop.source)
+                            direct_value_type = ViewEntity.from_id(prop.source)
 
                         dms_property = DMSProperty(
                             class_=class_entity,
                             property_=prop_id,
                             description=prop.description,
                             name=prop.name,
-                            value_type=cast(ViewPropEntity | DMSValueType, direct_value_type),
+                            value_type=direct_value_type,
                             relation="direct",
                             nullable=container_prop.nullable,
                             default=container_prop.default_value,
@@ -168,7 +167,7 @@ class DMSImporter(BaseImporter):
                             property_=prop_id,
                             description=prop.description,
                             name=prop.name,
-                            value_type=cast(ViewPropEntity | DMSValueType, container_prop.type._type),
+                            value_type=cast(ViewPropertyEntity | DataType, container_prop.type._type),
                             nullable=container_prop.nullable,
                             is_list=container_prop.type.is_list,
                             default=container_prop.default_value,
@@ -180,7 +179,7 @@ class DMSImporter(BaseImporter):
                             constraint=unique_constraints or None,
                         )
                 elif isinstance(prop, dm.MultiEdgeConnectionApply):
-                    view_entity = ViewPropEntity.from_id(prop.source)
+                    view_entity = ViewEntity.from_id(prop.source)
                     dms_property = DMSProperty(
                         class_=ClassEntity(prefix=view.space, suffix=view.external_id, version=view.version),
                         property_=prop_id,

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py

@@ -1,5 +1,6 @@
 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
@@ -20,13 +21,9 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
     TelemetryV2,
 )
 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.rules._information_rules import InformationClass, InformationProperty
-from cognite.neat.rules.models.rules._types import (
-    XSD_VALUE_TYPE_MAPPINGS,
-    ClassEntity,
-    ParentClassEntity,
-    XSDValueType,
-)
 
 
 class _DTDLConverter:
@@ -92,7 +89,12 @@ class _DTDLConverter:
             name=item.display_name,
             description=item.description,
             comment=item.comment,
-            parent=[ParentClassEntity.from_raw(parent.as_class_id()) for parent in item.extends or []] or None,
+            parent=[
+                cast(ParentClassEntity, parent_entity)
+                for parent in item.extends or []
+                if isinstance(parent_entity := ParentClassEntity.load(parent.as_class_id()), ParentClassEntity)
+            ]
+            or None,
         )
         self.classes.append(class_)
         for sub_item_or_id in item.contents or []:
@@ -123,7 +125,7 @@ class _DTDLConverter:
             return None
 
         prop = InformationProperty(
-            class_=ClassEntity.from_raw(parent),
+            class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
             description=item.description,
@@ -175,7 +177,7 @@ class _DTDLConverter:
         if value_type is None:
             return
         prop = InformationProperty(
-            class_=ClassEntity.from_raw(parent),
+            class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
             description=item.description,
@@ -195,7 +197,7 @@ class _DTDLConverter:
         if value_type is None:
             return
         prop = InformationProperty(
-            class_=ClassEntity.from_raw(parent),
+            class_=ClassEntity.load(parent),
             property_=item.name,
             name=item.display_name,
             description=item.description,
@@ -211,7 +213,7 @@ class _DTDLConverter:
             self._missing_parent_warning(item)
             return None
         if item.target is not None:
-            value_type: XSDValueType | ClassEntity
+            value_type: DataType | ClassEntity
             if item.target in self._item_by_id:
                 value_type = item.target.as_class_id()
             else:
@@ -223,10 +225,10 @@ class _DTDLConverter:
                         instance_id=item.target.model_dump(),
                     )
                 )
-                value_type = XSD_VALUE_TYPE_MAPPINGS["json"]
+                value_type = Json()
 
             prop = InformationProperty(
-                class_=ClassEntity.from_raw(parent),
+                class_=ClassEntity.load(parent),
                 property_=item.name,
                 name=item.display_name,
                 description=item.description,
@@ -275,13 +277,13 @@ class _DTDLConverter:
 
     def schema_to_value_type(
         self, schema: Schema | Interface | DTMI | None, item: DTDLBase
-    ) -> XSDValueType | ClassEntity | None:
+    ) -> DataType | ClassEntity | None:
         input_type = self._item_by_id.get(schema) if isinstance(schema, DTMI) else schema
 
         if isinstance(input_type, Enum):
-            return XSD_VALUE_TYPE_MAPPINGS["string"]
-        elif isinstance(input_type, str) and input_type in XSD_VALUE_TYPE_MAPPINGS:
-            return XSD_VALUE_TYPE_MAPPINGS[input_type]
+            return String()
+        elif isinstance(input_type, str) and input_type.casefold() in _DATA_TYPE_BY_NAME:
+            return _DATA_TYPE_BY_NAME[input_type.casefold()]()
         elif isinstance(input_type, str):
             self.issues.append(
                 cognite.neat.rules.issues.importing.UnsupportedPropertyTypeError(
@@ -301,11 +303,11 @@ class _DTDLConverter:
                         instance_name=input_type.display_name,
                     )
                 )
-                return XSD_VALUE_TYPE_MAPPINGS["json"]
+                return Json()
             else:
                 if isinstance(input_type, Object):
                     self.convert_object(input_type, None)
-                return ClassEntity.from_raw(input_type.id_.as_class_id())
+                return ClassEntity.load(input_type.id_.as_class_id())
         else:
             self.issues.append(
                 issues.importing.UnknownPropertyWarning(

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_dtdl2rules/spec.py

@@ -14,7 +14,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 
 from pydantic import BaseModel, Field, field_validator, model_serializer, model_validator
 
-from cognite.neat.rules.models.rules._types import ClassEntity
+from cognite.neat.rules.models.entities import ClassEntity
 
 if TYPE_CHECKING:
     from pydantic.type_adapter import IncEx

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_owl2rules/_owl2rules.py

@@ -10,8 +10,8 @@ from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
 from cognite.neat.rules.importers._base import BaseImporter, Rules
 from cognite.neat.rules.issues import IssueList
+from cognite.neat.rules.models.data_types import _XSD_TYPES
 from cognite.neat.rules.models.rules import InformationRules, RoleTypes
-from cognite.neat.rules.models.rules._types import XSD_VALUE_TYPE_MAPPINGS
 
 from ._owl2classes import parse_owl_classes
 from ._owl2metadata import parse_owl_metadata
@@ -126,7 +126,7 @@ def _add_missing_value_types(components: dict) -> dict:
         Updated tables with missing properties added to containers
     """
 
-    xsd_types = set(XSD_VALUE_TYPE_MAPPINGS.keys())
+    xsd_types = _XSD_TYPES
     candidate_value_types = {definition["Value Type"] for definition in components["Properties"]} - {
         definition["Class"] for definition in components["Classes"]
     }

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -15,6 +15,7 @@ from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, DomainRules, InformationRules
 from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness
+from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 
@@ -214,7 +215,11 @@ class ExcelImporter(BaseImporter):
             error_cls=issues.spreadsheet.InvalidSheetError,
             error_args={"read_info_by_sheet": read_info_by_sheet},
         ) as future:
-            rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
+            rules: Rules
+            if rules_cls is DMSRules:
+                rules = DMSRulesWrite.load(sheets).as_read()
+            else:
+                rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 
         if future.result == "failure" or issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/importers/_yaml2rules.py

@@ -5,7 +5,8 @@ import yaml
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList, NeatValidationError, ValidationIssue
-from cognite.neat.rules.models.rules import RULES_PER_ROLE, RoleTypes
+from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, RoleTypes
+from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
 
 from ._base import BaseImporter, Rules, _handle_issues
 
@@ -97,7 +98,12 @@ class YAMLImporter(BaseImporter):
         rules_model = RULES_PER_ROLE[role_enum]
 
         with _handle_issues(issue_list) as future:
-            rules = rules_model.model_validate(self.raw_data)
+            rules: Rules
+            if rules_model is DMSRules:
+                rules = DMSRulesWrite.load(self.raw_data).as_read()
+            else:
+                rules = rules_model.model_validate(self.raw_data)
+
         if future.result == "failure":
             if errors == "continue":
                 return None, issue_list

{cognite_neat-0.75.6 → cognite_neat-0.75.8}/cognite/neat/rules/issues/dms.py

@@ -195,7 +195,7 @@ class DirectRelationMissingSourceWarning(DMSSchemaWarning):
     property: str
 
     def message(self) -> str:
-        return f"The source view referred to by {self.view_id}.{self.property} does not exist"
+        return f"The source view referred to by '{self.view_id.external_id}.{self.property}' does not exist."
 
     def dump(self) -> dict[str, Any]:
         output = super().dump()