cognite-neat 0.75.7__py3-none-any.whl → 0.75.8__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.75.7"
+__version__ = "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/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/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/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/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/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/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/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/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/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/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/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()