cognite-neat 0.77.6__tar.gz → 0.77.8__tar.gz

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/PKG-INFO

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

cognite_neat-0.77.8/cognite/neat/_version.py

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

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/cognite/neat/rules/issues/importing.py

@@ -16,6 +16,7 @@ __all__ = [
     "MultipleDataModelsWarning",
     "UnknownPropertyTypeWarning",
     "FailedToInferValueTypeWarning",
+    "MoreThanOneNonAlphanumericCharacterWarning",
     "UnknownContainerConstraintWarning",
     "NoDataModelError",
     "ModelImportError",
@@ -275,6 +276,22 @@ class FailedImportWarning(ModelImportWarning):
         return {"identifier": list(self.identifier)}
 
 
+@dataclass(frozen=True)
+class MoreThanOneNonAlphanumericCharacterWarning(ModelImportWarning):
+    description = """This warning is raised when doing regex validation of strings which either represent class ids,
+    property ids, prefix, data model name, that contain more than one non-alphanumeric character,
+    such as for example '_' or '-'."""
+
+    field_name: str
+    value: str
+
+    def message(self) -> str:
+        return f"Field {self.field_name} with value {self.value} contains more than one non-alphanumeric character!"
+
+    def dump(self) -> dict[str, str]:
+        return {"field_name": self.field_name, "value": self.value}
+
+
 @dataclass(frozen=True)
 class ModelImportError(NeatValidationError, ABC):
     description = "An error was raised during importing."

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/cognite/neat/rules/models/_types/_field.py

@@ -1,4 +1,5 @@
 import re
+import warnings
 from collections.abc import Callable
 from typing import Annotated, Any, cast
 
@@ -17,6 +18,7 @@ from pydantic.functional_serializers import PlainSerializer
 from pydantic_core import PydanticCustomError
 
 from cognite.neat.rules import exceptions
+from cognite.neat.rules.issues.importing import MoreThanOneNonAlphanumericCharacterWarning
 
 from ._base import (
     MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX,
@@ -50,7 +52,6 @@ StrOrListType = Annotated[
     ),
 ]
 
-
 StrListType = Annotated[
     list[str],
     BeforeValidator(lambda value: [entry.strip() for entry in value.split(",")] if isinstance(value, str) else value),
@@ -96,19 +97,12 @@ VersionType = Annotated[
 ]
 
 
-PropertyType = Annotated[
-    str,
-    AfterValidator(
-        lambda value: (
-            _raise(exceptions.MoreThanOneNonAlphanumericCharacter("property", value).to_pydantic_custom_error())
-            if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, value)
-            else (
-                value
-                if re.match(PROPERTY_ID_COMPLIANCE_REGEX, value)
-                else _raise(
-                    exceptions.PropertyIDRegexViolation(value, PROPERTY_ID_COMPLIANCE_REGEX).to_pydantic_custom_error()
-                )
-            )
-        )
-    ),
-]
+def _property_validation(value: str) -> str:
+    if not re.match(PROPERTY_ID_COMPLIANCE_REGEX, value):
+        _raise(exceptions.PropertyIDRegexViolation(value, PROPERTY_ID_COMPLIANCE_REGEX).to_pydantic_custom_error())
+    if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, value):
+        warnings.warn(MoreThanOneNonAlphanumericCharacterWarning("property", value), stacklevel=2)
+    return value
+
+
+PropertyType = Annotated[str, AfterValidator(_property_validation)]

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/cognite/neat/rules/models/dms/_validation.py

@@ -57,7 +57,10 @@ class DMSPostValidation:
             container_id = container.as_id()
             row_numbers = {prop_no for prop_no, _ in properties}
             value_types = {prop.value_type for _, prop in properties if prop.value_type}
-            if len(value_types) > 1:
+            # The container type 'direct' is an exception. On a container the type direct can point to any
+            # node. The value type is typically set on the view.
+            is_all_direct = all(prop.connection == "direct" for _, prop in properties)
+            if len(value_types) > 1 and not is_all_direct:
                 errors.append(
                     issues.spreadsheet.MultiValueTypeError(
                         container_id,

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/cognite/neat/rules/models/information/_converter.py

@@ -1,5 +1,6 @@
 import re
-from collections import defaultdict
+from collections import Counter, defaultdict
+from collections.abc import Collection
 from typing import TYPE_CHECKING, Literal
 
 from cognite.neat.rules.models._base import (
@@ -40,7 +41,6 @@ class _InformationRulesConverter:
             self.last_classes = {class_.class_: class_ for class_ in self.rules.last.classes}
         else:
             self.last_classes = {}
-        self._created_classes_from: dict[ClassEntity, ClassEntity] = {}
 
     def as_domain_rules(self) -> DomainRules:
         raise NotImplementedError("DomainRules not implemented yet")
@@ -58,11 +58,13 @@ class _InformationRulesConverter:
         default_space = self._to_space(info_metadata.prefix)
         metadata = self._convert_metadata_to_dms(info_metadata)
 
-        properties_by_class: dict[str, list[DMSProperty]] = defaultdict(list)
+        properties_by_class: dict[ClassEntity, list[DMSProperty]] = defaultdict(list)
+        referenced_containers: dict[ContainerEntity, Counter[ClassEntity]] = defaultdict(Counter)
         for prop in self.rules.properties:
-            properties_by_class[prop.class_.versioned_id].append(
-                self._as_dms_property(prop, default_space, default_version)
-            )
+            dms_property = self._as_dms_property(prop, default_space, default_version)
+            properties_by_class[prop.class_].append(dms_property)
+            if dms_property.container:
+                referenced_containers[dms_property.container][prop.class_] += 1
 
         views: list[DMSView] = [
             DMSView(
@@ -76,41 +78,37 @@ class _InformationRulesConverter:
             for cls_ in self.rules.classes
         ]
 
-        classes_without_properties: set[str] = set()
-        for class_ in self.rules.classes:
-            properties: list[DMSProperty] = properties_by_class.get(class_.class_.versioned_id, [])
-            if not properties or all(
-                isinstance(prop.value_type, ViewPropertyEntity) and prop.connection != "direct" for prop in properties
-            ):
-                classes_without_properties.add(class_.class_.versioned_id)
+        last_dms_rules = self.rules.last.as_dms_architect_rules() if self.rules.last else None
+        ref_dms_rules = self.rules.reference.as_dms_architect_rules() if self.rules.reference else None
 
         containers: list[DMSContainer] = []
-        classes = list(self.rules.classes)
-        for new_class_entity, created_from in self._created_classes_from.items():
-            # We create new classes in case metadata is set to addition or reshape
-            # and the class was present in the last schema to avoid creating
-            # a changed container and instead create a new one.
-            created_class = self.last_classes[created_from].copy(deep=True)
-            created_class.class_ = new_class_entity
-            classes.append(created_class)
-
-        for class_ in classes:
-            if class_.class_.versioned_id in classes_without_properties:
+        class_by_entity = {cls_.class_: cls_ for cls_ in self.rules.classes}
+        if self.rules.last:
+            for cls_ in self.rules.last.classes:
+                if cls_.class_ not in class_by_entity:
+                    class_by_entity[cls_.class_] = cls_
+
+        existing_containers: set[ContainerEntity] = set()
+        for rule_set in [last_dms_rules, ref_dms_rules]:
+            if rule_set:
+                existing_containers.update({c.container for c in rule_set.containers or []})
+
+        for container_entity, class_entities in referenced_containers.items():
+            if container_entity in existing_containers:
                 continue
-            containers.append(
-                DMSContainer(
-                    class_=class_.class_,
-                    name=class_.name,
-                    container=class_.class_.as_container_entity(default_space),
-                    description=class_.description,
-                    constraint=[
-                        parent.as_container_entity(default_space)
-                        for parent in class_.parent or []
-                        if parent.versioned_id not in classes_without_properties
-                    ]
-                    or None,
-                )
+            constrains = self._create_container_constraint(
+                class_entities, default_space, class_by_entity, referenced_containers
+            )
+            most_used_class_entity = class_entities.most_common(1)[0][0]
+            class_ = class_by_entity[most_used_class_entity]
+            container = DMSContainer(
+                class_=class_.class_,
+                container=container_entity,
+                name=class_.name,
+                description=class_.description,
+                constraint=constrains or None,
             )
+            containers.append(container)
 
         return DMSRules(
             metadata=metadata,
@@ -119,10 +117,26 @@ class _InformationRulesConverter:
             ),
             views=SheetList[DMSView](data=views),
             containers=SheetList[DMSContainer](data=containers),
-            last=self.rules.last.as_dms_architect_rules() if self.rules.last else None,
-            reference=self.rules.reference.as_dms_architect_rules() if self.rules.reference else None,
+            last=last_dms_rules,
+            reference=ref_dms_rules,
         )
 
+    @staticmethod
+    def _create_container_constraint(
+        class_entities: Counter[ClassEntity],
+        default_space: str,
+        class_by_entity: dict[ClassEntity, InformationClass],
+        referenced_containers: Collection[ContainerEntity],
+    ) -> list[ContainerEntity]:
+        constrains: list[ContainerEntity] = []
+        for entity in class_entities:
+            class_ = class_by_entity[entity]
+            for parent in class_.parent or []:
+                parent_entity = parent.as_container_entity(default_space)
+                if parent_entity in referenced_containers:
+                    constrains.append(parent_entity)
+        return constrains
+
     @classmethod
     def _convert_metadata_to_dms(cls, metadata: InformationMetadata) -> "DMSMetadata":
         from cognite.neat.rules.models.dms._rules import (
@@ -211,25 +225,35 @@ class _InformationRulesConverter:
         elif (self.is_addition or self.is_reshape) and prop.class_ in self.last_classes:
             # We need to create a new container for the property, as we cannot change
             # the existing container in the last schema
-            class_entity = prop.class_.copy()
-            class_entity.suffix = self._bump_suffix(class_entity.suffix)
-            if class_entity not in self._created_classes_from:
-                self._created_classes_from[class_entity] = prop.class_
-            return class_entity.as_container_entity(default_space), prop.property_
+            container_entity = prop.class_.as_container_entity(default_space)
+            container_entity.suffix = self._bump_suffix(container_entity.suffix)
+            return container_entity, prop.property_
         else:
             return prop.class_.as_container_entity(default_space), prop.property_
 
-    @classmethod
-    def _get_view_implements(cls, cls_: InformationClass, metadata: InformationMetadata) -> list[ViewEntity]:
+    def _get_view_implements(self, cls_: InformationClass, metadata: InformationMetadata) -> list[ViewEntity]:
         if isinstance(cls_.reference, ReferenceEntity) and cls_.reference.prefix != metadata.prefix:
             # We use the reference for implements if it is in a different namespace
-            implements = [
-                cls_.reference.as_view_entity(metadata.prefix, metadata.version),
-            ]
+            if self.rules.reference and cls_.reference.prefix == self.rules.reference.metadata.prefix:
+                implements = [
+                    cls_.reference.as_view_entity(
+                        self.rules.reference.metadata.prefix, self.rules.reference.metadata.version
+                    )
+                ]
+            else:
+                implements = [
+                    cls_.reference.as_view_entity(metadata.prefix, metadata.version),
+                ]
         else:
             implements = []
-
-        implements.extend([parent.as_view_entity(metadata.prefix, metadata.version) for parent in cls_.parent or []])
+        for parent in cls_.parent or []:
+            if self.rules.reference and parent.prefix == self.rules.reference.metadata.prefix:
+                view_entity = parent.as_view_entity(
+                    self.rules.reference.metadata.prefix, self.rules.reference.metadata.version
+                )
+            else:
+                view_entity = parent.as_view_entity(metadata.prefix, metadata.version)
+            implements.append(view_entity)
         return implements
 
     @staticmethod

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/cognite/neat/workflows/steps/lib/current/rules_exporter.py

@@ -281,7 +281,6 @@ class RulesToExcel(Step):
             value="",
             label="If you chose Dump Format 'reference', the provided ID will be use in the new medata sheet. "
             "Expected format 'sp_space:my_external_id'.",
-            options=list(exporters.ExcelExporter.dump_options),
         ),
         Configurable(
             name="File path",

{cognite_neat-0.77.6 → cognite_neat-0.77.8}/pyproject.toml

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

cognite_neat-0.77.6/cognite/neat/_version.py

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