cognite-neat 0.109.2__tar.gz → 0.109.3__tar.gz

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.109.2
+Version: 0.109.3
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_alpha.py

@@ -12,3 +12,4 @@ class AlphaWarning(UserWarning):
 class AlphaFlags:
     manual_rules_edit = AlphaWarning("enable_manual_edit")
     same_space_properties_only_export = AlphaWarning("same-space-properties-only")
+    standardize_naming = AlphaWarning("standardize_naming")

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_client/testing.py

@@ -19,7 +19,7 @@ class NeatClientMock(CogniteClientMock):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         if "parent" in kwargs:
             super().__init__(*args, **kwargs)
-            return None
+            return
         super().__init__(*args, **kwargs)
         self.schema = SchemaAPI(self)
         self.loaders = DataModelLoaderAPI(self)

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_issues/_base.py

@@ -103,6 +103,8 @@ class NeatIssue:
                 variables[name] = var_.as_posix()
             elif isinstance(var_, Collection):
                 variables[name] = humanize_collection(var_)
+            elif isinstance(var_, NeatError):
+                variables[name] = var_.as_message(include_type=False)
             else:
                 variables[name] = repr(var_)
         return variables, has_all_optional
@@ -138,6 +140,8 @@ class NeatIssue:
             return value.dump(camel_case=True)
         elif isinstance(value, DataModelId):
             return value.dump(camel_case=True, include_type=False)
+        elif isinstance(value, NeatError):
+            return value.dump()
         raise ValueError(f"Unsupported type: {type(value)}")
 
     @classmethod
@@ -192,6 +196,8 @@ class NeatIssue:
             return ContainerId.load(value)
         elif inspect.isclass(type_) and issubclass(type_, Entity):
             return type_.load(value)
+        elif type_ is NeatError:
+            return cls.load(value)
         return value
 
     def __lt__(self, other: "NeatIssue") -> bool:
@@ -227,22 +233,19 @@ class NeatError(NeatIssue, Exception):
                 # Skip the error for SheetList, as it is not relevant for the user. This is an
                 # internal class used to have helper methods for a lists as .to_pandas()
                 continue
+
             neat_error: NeatError | None = None
             if isinstance(error, dict) and isinstance(ctx := error.get("ctx"), dict) and "error" in ctx:
                 neat_error = ctx["error"]
             elif isinstance(error, NeatError | MultiValueError):
                 neat_error = error
 
+            loc = error["loc"] if isinstance(error, dict) else tuple()
             if isinstance(neat_error, MultiValueError):
-                if read_info_by_sheet:
-                    for caught_error in neat_error.errors:
-                        cls._adjust_row_numbers(caught_error, read_info_by_sheet)  # type: ignore[arg-type]
-                all_errors.extend(neat_error.errors)  # type: ignore[arg-type]
+                all_errors.extend([cls._adjust_error(e, loc, read_info_by_sheet) for e in neat_error.errors])
             elif isinstance(neat_error, NeatError):
-                if read_info_by_sheet:
-                    cls._adjust_row_numbers(neat_error, read_info_by_sheet)
-                all_errors.append(neat_error)
-            elif isinstance(error, dict) and len(error["loc"]) >= 4 and read_info_by_sheet:
+                all_errors.append(cls._adjust_error(neat_error, loc, read_info_by_sheet))
+            elif isinstance(error, dict) and len(loc) >= 4 and read_info_by_sheet:
                 all_errors.append(RowError.from_pydantic_error(error, read_info_by_sheet))
             elif isinstance(error, dict):
                 all_errors.append(DefaultPydanticError.from_pydantic_error(error))
@@ -251,6 +254,18 @@ class NeatError(NeatIssue, Exception):
                 raise ValueError(f"Unsupported error type: {error}")
         return all_errors
 
+    @classmethod
+    def _adjust_error(
+        cls, error: "NeatError", loc: tuple[str | int, ...], read_info_by_sheet: dict[str, SpreadsheetRead] | None
+    ) -> "NeatError":
+        from .errors._wrapper import MetadataValueError
+
+        if read_info_by_sheet:
+            cls._adjust_row_numbers(error, read_info_by_sheet)
+        if len(loc) == 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
+            return MetadataValueError(field_name=str(loc[1]), error=error)
+        return error
+
     @staticmethod
     def _adjust_row_numbers(caught_error: "NeatError", read_info_by_sheet: dict[str, SpreadsheetRead]) -> None:
         from cognite.neat._issues.errors._properties import PropertyDefinitionDuplicatedError
@@ -288,7 +303,16 @@ class DefaultPydanticError(NeatError, ValueError):
     msg: str
 
     @classmethod
-    def from_pydantic_error(cls, error: ErrorDetails) -> "DefaultPydanticError":
+    def from_pydantic_error(cls, error: ErrorDetails) -> "NeatError":
+        loc = error["loc"]
+        if len(loc) >= 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
+            from .errors._general import NeatValueError
+            from .errors._wrapper import MetadataValueError
+
+            return MetadataValueError(
+                field_name=str(loc[1]), error=NeatValueError(f"{error['msg']} got '{error['input']}'")
+            )
+
         return cls(
             type=error["type"],
             loc=error["loc"],

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_issues/errors/__init__.py

@@ -31,12 +31,7 @@ from ._resources import (
     ResourceNotFoundError,
     ResourceRetrievalError,
 )
-from ._workflow import (
-    WorkflowConfigurationNotSetError,
-    WorkFlowMissingDataError,
-    WorkflowStepNotInitializedError,
-    WorkflowStepOutputError,
-)
+from ._wrapper import MetadataValueError
 
 __all__ = [
     "AuthorizationError",
@@ -47,6 +42,7 @@ __all__ = [
     "FileNotFoundNeatError",
     "FileReadError",
     "FileTypeUnexpectedError",
+    "MetadataValueError",
     "NeatError",
     "NeatImportError",
     "NeatTypeError",
@@ -70,10 +66,6 @@ __all__ = [
     "ResourceRetrievalError",
     "ReversedConnectionNotFeasibleError",
     "RowError",
-    "WorkFlowMissingDataError",
-    "WorkflowConfigurationNotSetError",
-    "WorkflowStepNotInitializedError",
-    "WorkflowStepOutputError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_issues/errors/_general.py

@@ -19,7 +19,7 @@ class NeatTypeError(NeatError, TypeError):
 
 @dataclass(unsafe_hash=True)
 class RegexViolationError(NeatError, ValueError):
-    """Value, {value} in {location} failed regex, {regex}, validation.
+    """The value '{value}' failed regex, {regex}, validation in {location}.
     Make sure that the name follows the regex pattern."""
 
     value: str

cognite_neat-0.109.3/cognite/neat/_issues/errors/_wrapper.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from cognite.neat._issues import NeatError
+
+
+@dataclass(unsafe_hash=True)
+class MetadataValueError(NeatError, ValueError):
+    """Field {field_name} - {error}"""
+
+    field_name: str
+    error: NeatError

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/models/_rdfpath.py

@@ -2,6 +2,7 @@
 
 import re
 import sys
+import urllib.parse
 from collections import Counter
 from functools import total_ordering
 from typing import ClassVar, Literal
@@ -327,6 +328,7 @@ def parse_table_lookup(raw: str) -> TableLookup:
 
 
 def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
+    rule_raw = urllib.parse.unquote(rule_raw)
     match rule_type:
         case TransformationRuleType.rdfpath:
             rule_raw = rule_raw.replace(" ", "")

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/models/_types.py

@@ -38,7 +38,9 @@ def _custom_error(exc_factory: Callable[[str | None, Exception], Any]) -> Any:
     def _validator(value: Any, next_: Any, ctx: ValidationInfo) -> Any:
         try:
             return next_(value, ctx)
-        except Exception:
+        except ValueError as e:
+            if value is None:
+                raise e
             raise exc_factory(ctx.field_name, value) from None
 
     return WrapValidator(_validator)
@@ -130,7 +132,7 @@ def _external_id_validation_factory(entity_type: EntityTypes, location: str):
 
 SpaceType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.space, "space entry in metadata")),
+    AfterValidator(_external_id_validation_factory(EntityTypes.space, "")),
 ]
 
 InformationPropertyType = Annotated[

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/models/dms/_rules.py

@@ -1,4 +1,3 @@
-import warnings
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
@@ -8,11 +7,7 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat._client.data_classes.schema import DMSSchema
-from cognite.neat._constants import COGNITE_SPACES
 from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._issues.warnings import (
-    PrincipleMatchingSpaceAndVersionWarning,
-)
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
@@ -407,37 +402,6 @@ class DMSRules(BaseRules):
         None, alias="Nodes", description="Contains the definition of the node types."
     )
 
-    @field_validator("views")
-    def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
-        if not (metadata := info.data.get("metadata")):
-            return value
-        model_version = metadata.version
-        if different_version := [
-            view.view.as_id()
-            for view in value
-            if view.view.version != model_version and view.view.space not in COGNITE_SPACES
-        ]:
-            for view_id in different_version:
-                warnings.warn(
-                    PrincipleMatchingSpaceAndVersionWarning(
-                        f"The view {view_id!r} has a different version than the data model version, {model_version}",
-                    ),
-                    stacklevel=2,
-                )
-        if different_space := [
-            view.view.as_id()
-            for view in value
-            if view.view.space != metadata.space and view.view.space not in COGNITE_SPACES
-        ]:
-            for view_id in different_space:
-                warnings.warn(
-                    PrincipleMatchingSpaceAndVersionWarning(
-                        f"The view {view_id!r} is in a different space than the data model space, {metadata.space}",
-                    ),
-                    stacklevel=2,
-                )
-        return value
-
     @model_validator(mode="after")
     def set_neat_id(self) -> "DMSRules":
         namespace = self.metadata.namespace

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/models/entities/_constants.py

@@ -8,6 +8,9 @@ class _UnknownType(BaseModel):
     def __str__(self) -> str:
         return "#N/A"
 
+    def __hash__(self):
+        return hash(str(self))
+
 
 # This is a trick to make Undefined and Unknown singletons
 Undefined = _UndefinedType()

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/models/entities/_single_value.py

@@ -134,7 +134,12 @@ class Entity(BaseModel, extra="ignore"):
         content = result.group("content")
         if content is None:
             return dict(prefix=prefix, suffix=suffix)
-        extra_args = dict(SPLIT_ON_EQUAL_PATTERN.split(pair.strip()) for pair in SPLIT_ON_COMMA_PATTERN.split(content))
+        try:
+            extra_args = dict(
+                SPLIT_ON_EQUAL_PATTERN.split(pair.strip()) for pair in SPLIT_ON_COMMA_PATTERN.split(content)
+            )
+        except ValueError:
+            raise NeatValueError(f"Invalid {cls.type_.value} entity: {raw!r}") from None
         expected_args = {
             field_.alias or field_name: field_.annotation for field_name, field_ in cls.model_fields.items()
         }

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/transformers/__init__.py

@@ -13,10 +13,12 @@ from ._converters import (
     MergeInformationRules,
     PrefixEntities,
     SetIDDMSModel,
+    StandardizeNaming,
     ToCompliantEntities,
     ToDataProductModel,
     ToEnterpriseModel,
     ToExtensionModel,
+    ToInformationCompliantEntities,
     ToSolutionModel,
 )
 from ._mapping import AsParentPropertyId, MapOneToOne, RuleMapper
@@ -40,10 +42,12 @@ __all__ = [
     "RuleMapper",
     "RulesTransformer",
     "SetIDDMSModel",
+    "StandardizeNaming",
     "ToCompliantEntities",
     "ToDataProductModel",
     "ToEnterpriseModel",
     "ToExtensionModel",
+    "ToInformationCompliantEntities",
     "ToSolutionModel",
     "VerifiedRulesTransformer",
     "VerifyAnyRules",

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_rules/transformers/_converters.py

@@ -1,9 +1,11 @@
 import re
+import urllib.parse
 import warnings
 from abc import ABC
 from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
+from functools import cached_property
 from typing import ClassVar, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import data_modeling as dms
@@ -23,11 +25,12 @@ from cognite.neat._constants import (
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import NeatValueWarning
 from cognite.neat._issues.warnings._models import (
-    EnterpriseModelNotBuildOnTopOfCDMWarning,
     SolutionModelBuildOnTopOfCDMWarning,
 )
+from cognite.neat._rules._constants import PATTERNS, get_reserved_words
 from cognite.neat._rules._shared import (
     ReadInputRules,
+    ReadRules,
     VerifiedRules,
 )
 from cognite.neat._rules.analysis import DMSAnalysis
@@ -35,6 +38,7 @@ from cognite.neat._rules.importers import DMSImporter
 from cognite.neat._rules.models import (
     DMSInputRules,
     DMSRules,
+    InformationInputRules,
     InformationRules,
     SheetList,
     data_types,
@@ -56,9 +60,9 @@ from cognite.neat._rules.models.entities import (
     ViewEntity,
 )
 from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
-from cognite.neat._utils.text import to_camel
+from cognite.neat._utils.text import NamingStandardization, to_camel
 
-from ._base import T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
+from ._base import RulesTransformer, T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
 from ._verification import VerifyDMSRules
 
 T_InputInRules = TypeVar("T_InputInRules", bound=ReadInputRules)
@@ -71,6 +75,105 @@ class ConversionTransformer(VerifiedRulesTransformer[T_VerifiedIn, T_VerifiedOut
     ...
 
 
+class ToInformationCompliantEntities(
+    RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]
+):
+    """Converts input rules to rules that is compliant with the Information Model.
+
+    This is typically used with importers from arbitrary sources to ensure that classes and properties have valid
+    names.
+
+    Args:
+        renaming: How to handle renaming of entities that are not compliant with the Information Model.
+            - "warning": Raises a warning and renames the entity.
+            - "skip": Renames the entity without raising a warning.
+    """
+
+    def __init__(self, renaming: Literal["warning", "skip"] = "skip") -> None:
+        self._renaming = renaming
+
+    @property
+    def description(self) -> str:
+        return "Ensures that all entities are compliant with the Information Model."
+
+    def transform(self, rules: ReadRules[InformationInputRules]) -> ReadRules[InformationInputRules]:
+        if rules.rules is None:
+            return rules
+        # Doing dump to obtain a copy, and ensure that all entities are created. Input allows
+        # string for entities, the dump call will convert these to entities.
+        dumped = rules.rules.dump()
+        copy = InformationInputRules.load(dumped)
+
+        new_by_old_class_suffix: dict[str, str] = {}
+        for cls in copy.classes:
+            cls_entity = cast(ClassEntity, cls.class_)  # Safe due to the dump above
+            if not PATTERNS.class_id_compliance.match(cls_entity.suffix):
+                new_suffix = self._fix_cls_suffix(cls_entity.suffix)
+                if self._renaming == "warning":
+                    warnings.warn(
+                        NeatValueWarning(f"Invalid class name {cls_entity.suffix!r}.Renaming to {new_suffix}"),
+                        stacklevel=2,
+                    )
+                cls.class_.suffix = new_suffix  # type: ignore[union-attr]
+
+        for cls_ in copy.classes:
+            if cls_.implements:
+                for i, parent in enumerate(cls_.implements):
+                    if isinstance(parent, ClassEntity) and parent.suffix in new_by_old_class_suffix:
+                        cls_.implements[i].suffix = new_by_old_class_suffix[parent.suffix]  # type: ignore[union-attr]
+
+        for prop in copy.properties:
+            if not PATTERNS.information_property_id_compliance.match(prop.property_):
+                new_property = self._fix_property(prop.property_)
+                if self._renaming == "warning":
+                    warnings.warn(
+                        NeatValueWarning(
+                            f"Invalid property name {prop.class_.suffix}.{prop.property_!r}. Renaming to {new_property}"  # type: ignore[union-attr]
+                        ),
+                        stacklevel=2,
+                    )
+                prop.property_ = new_property
+
+            if isinstance(prop.class_, ClassEntity) and prop.class_.suffix in new_by_old_class_suffix:
+                prop.class_.suffix = new_by_old_class_suffix[prop.class_.suffix]
+
+            if isinstance(prop.value_type, ClassEntity) and prop.value_type.suffix in new_by_old_class_suffix:
+                prop.value_type.suffix = new_by_old_class_suffix[prop.value_type.suffix]
+
+            if isinstance(prop.value_type, MultiValueTypeInfo):
+                for i, value_type in enumerate(prop.value_type.types):
+                    if isinstance(value_type, ClassEntity) and value_type.suffix in new_by_old_class_suffix:
+                        prop.value_type.types[i].suffix = new_by_old_class_suffix[value_type.suffix]  # type: ignore[union-attr]
+
+        return ReadRules(rules=copy, read_context=rules.read_context)
+
+    @cached_property
+    def _reserved_class_words(self) -> set[str]:
+        return set(get_reserved_words("class"))
+
+    @cached_property
+    def _reserved_property_words(self) -> set[str]:
+        return set(get_reserved_words("property"))
+
+    def _fix_cls_suffix(self, suffix: str) -> str:
+        if suffix in self._reserved_class_words:
+            return f"My{suffix}"
+        suffix = urllib.parse.unquote(suffix)
+        suffix = NamingStandardization.standardize_class_str(suffix)
+        if len(suffix) > 252:
+            suffix = suffix[:252]
+        return suffix
+
+    def _fix_property(self, property_: str) -> str:
+        if property_ in self._reserved_property_words:
+            return f"my{property_}"
+        property_ = urllib.parse.unquote(property_)
+        property_ = NamingStandardization.standardize_property_str(property_)
+        if len(property_) > 252:
+            property_ = property_[:252]
+        return property_
+
+
 class ToCompliantEntities(VerifiedRulesTransformer[InformationRules, InformationRules]):  # type: ignore[misc]
     """Converts input rules to rules with compliant entity IDs that match regex patters used
     by DMS schema components."""
@@ -246,6 +349,116 @@ class PrefixEntities(ConversionTransformer):  # type: ignore[type-var]
         return entity
 
 
+class StandardizeNaming(ConversionTransformer):
+    """Sets views/classes/container names to PascalCase and properties to camelCase."""
+
+    @property
+    def description(self) -> str:
+        return "Sets views/classes/containers names to PascalCase and properties to camelCase."
+
+    @overload
+    def transform(self, rules: DMSRules) -> DMSRules: ...
+
+    @overload
+    def transform(self, rules: InformationRules) -> InformationRules: ...
+
+    def transform(self, rules: InformationRules | DMSRules) -> InformationRules | DMSRules:
+        output = rules.model_copy(deep=True)
+        if isinstance(output, InformationRules):
+            return self._standardize_information_rules(output)
+        elif isinstance(output, DMSRules):
+            return self._standardize_dms_rules(output)
+        raise NeatValueError(f"Unsupported rules type: {type(output)}")
+
+    def _standardize_information_rules(self, rules: InformationRules) -> InformationRules:
+        new_by_old_class_suffix: dict[str, str] = {}
+        for cls in rules.classes:
+            new_suffix = NamingStandardization.standardize_class_str(cls.class_.suffix)
+            new_by_old_class_suffix[cls.class_.suffix] = new_suffix
+            cls.class_.suffix = new_suffix
+
+        for cls in rules.classes:
+            if cls.implements:
+                for i, parent in enumerate(cls.implements):
+                    if parent.suffix in new_by_old_class_suffix:
+                        cls.implements[i].suffix = new_by_old_class_suffix[parent.suffix]
+
+        for prop in rules.properties:
+            prop.property_ = NamingStandardization.standardize_property_str(prop.property_)
+            if prop.class_.suffix in new_by_old_class_suffix:
+                prop.class_.suffix = new_by_old_class_suffix[prop.class_.suffix]
+
+            if isinstance(prop.value_type, ClassEntity) and prop.value_type.suffix in new_by_old_class_suffix:
+                prop.value_type.suffix = new_by_old_class_suffix[prop.value_type.suffix]
+
+            if isinstance(prop.value_type, MultiValueTypeInfo):
+                for i, value_type in enumerate(prop.value_type.types):
+                    if isinstance(value_type, ClassEntity) and value_type.suffix in new_by_old_class_suffix:
+                        prop.value_type.types[i].suffix = new_by_old_class_suffix[value_type.suffix]  # type: ignore[union-attr]
+
+        return rules
+
+    def _standardize_dms_rules(self, rules: DMSRules) -> DMSRules:
+        new_by_old_view: dict[str, str] = {}
+        for view in rules.views:
+            new_suffix = NamingStandardization.standardize_class_str(view.view.suffix)
+            new_by_old_view[view.view.suffix] = new_suffix
+            view.view.suffix = new_suffix
+        new_by_old_container: dict[str, str] = {}
+        if rules.containers:
+            for container in rules.containers:
+                new_suffix = NamingStandardization.standardize_class_str(container.container.suffix)
+                new_by_old_container[container.container.suffix] = new_suffix
+                container.container.suffix = new_suffix
+
+        for view in rules.views:
+            if view.implements:
+                for i, parent in enumerate(view.implements):
+                    if parent.suffix in new_by_old_view:
+                        view.implements[i].suffix = new_by_old_view[parent.suffix]
+            if view.filter_ and isinstance(view.filter_, HasDataFilter) and view.filter_.inner:
+                for i, item in enumerate(view.filter_.inner):
+                    if isinstance(item, ContainerEntity) and item.suffix in new_by_old_container:
+                        view.filter_.inner[i].suffix = new_by_old_container[item.suffix]
+                    if isinstance(item, ViewEntity) and item.suffix in new_by_old_view:
+                        view.filter_.inner[i].suffix = new_by_old_view[item.suffix]
+        if rules.containers:
+            for container in rules.containers:
+                if container.constraint:
+                    for i, constraint in enumerate(container.constraint):
+                        if constraint.suffix in new_by_old_container:
+                            container.constraint[i].suffix = new_by_old_container[constraint.suffix]
+        new_property_by_view_by_old_property: dict[ViewEntity, dict[str, str]] = defaultdict(dict)
+        for prop in rules.properties:
+            if prop.view.suffix in new_by_old_view:
+                prop.view.suffix = new_by_old_view[prop.view.suffix]
+            new_view_property = NamingStandardization.standardize_property_str(prop.view_property)
+            new_property_by_view_by_old_property[prop.view][prop.view_property] = new_view_property
+            prop.view_property = new_view_property
+            if isinstance(prop.value_type, ViewEntity) and prop.value_type.suffix in new_by_old_view:
+                prop.value_type.suffix = new_by_old_view[prop.value_type.suffix]
+            if (
+                isinstance(prop.connection, EdgeEntity)
+                and prop.connection.properties
+                and prop.connection.properties.suffix in new_by_old_view
+            ):
+                prop.connection.properties.suffix = new_by_old_view[prop.connection.properties.suffix]
+            if isinstance(prop.container, ContainerEntity) and prop.container.suffix in new_by_old_container:
+                prop.container.suffix = new_by_old_container[prop.container.suffix]
+            if prop.container_property:
+                prop.container_property = NamingStandardization.standardize_property_str(prop.container_property)
+        for prop in rules.properties:
+            if (
+                isinstance(prop.connection, ReverseConnectionEntity)
+                and isinstance(prop.value_type, ViewEntity)
+                and prop.value_type in new_property_by_view_by_old_property
+            ):
+                new_by_old_property = new_property_by_view_by_old_property[prop.value_type]
+                if prop.connection.property_ in new_by_old_property:
+                    prop.connection.property_ = new_by_old_property[prop.connection.property_]
+        return rules
+
+
 class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
@@ -339,13 +552,6 @@ class ToEnterpriseModel(ToExtensionModel):
         self.move_connections = move_connections
 
     def transform(self, rules: DMSRules) -> DMSRules:
-        reference_model_id = rules.metadata.as_data_model_id()
-        if reference_model_id not in COGNITE_MODELS:
-            warnings.warn(
-                EnterpriseModelNotBuildOnTopOfCDMWarning(reference_model_id=reference_model_id).as_message(),
-                stacklevel=2,
-            )
-
         return self._to_enterprise(rules)
 
     def _to_enterprise(self, reference_model: DMSRules) -> DMSRules:
@@ -565,12 +771,10 @@ class ToSolutionModel(ToExtensionModel):
         renaming: dict[ViewEntity, ViewEntity] = {}
         new_views = SheetList[DMSView]()
         read_view_by_new_view: dict[ViewEntity, ViewEntity] = {}
-        skipped_views: set[ViewEntity] = set()
         for ref_view in reference.views:
             if (self.skip_cognite_views and ref_view.view.space in COGNITE_SPACES) or (
                 self.exclude_views_in_other_spaces and ref_view.view.space != reference.metadata.space
             ):
-                skipped_views.add(ref_view.view)
                 continue
             new_entity = ViewEntity(
                 # MyPy we validate that version is string in the constructor
@@ -603,15 +807,17 @@ class ToSolutionModel(ToExtensionModel):
             new_views.append(ref_view.model_copy(deep=True, update={"implements": None, "view": new_entity}))
 
         new_properties = SheetList[DMSProperty]()
+        new_view_entities = {view.view for view in new_views}
         for prop in reference.properties:
-            if prop.view in skipped_views:
-                continue
             new_property = prop.model_copy(deep=True)
             if new_property.value_type in renaming and isinstance(new_property.value_type, ViewEntity):
                 new_property.value_type = renaming[new_property.value_type]
             if new_property.view in renaming:
                 new_property.view = renaming[new_property.view]
-            new_properties.append(new_property)
+            if new_property.view in new_view_entities and (
+                not isinstance(new_property.value_type, ViewEntity) or new_property.value_type in new_view_entities
+            ):
+                new_properties.append(new_property)
         return new_views, new_properties, read_view_by_new_view
 
     def _create_containers_update_view_filter(

{cognite_neat-0.109.2 → cognite_neat-0.109.3}/cognite/neat/_session/_base.py

@@ -16,6 +16,7 @@ from cognite.neat._rules.transformers import (
     InformationToDMS,
     MergeDMSRules,
     MergeInformationRules,
+    ToInformationCompliantEntities,
     VerifyInformationRules,
 )
 from cognite.neat._store._rules_store import RulesEntity
@@ -235,13 +236,19 @@ class NeatSession:
 
         def action() -> tuple[InformationRules, DMSRules | None]:
             unverified_information = importer.to_rules()
+            unverified_information = ToInformationCompliantEntities(renaming="warning").transform(
+                unverified_information
+            )
+
             extra_info = VerifyInformationRules().transform(unverified_information)
             if not last_entity:
                 return extra_info, None
             merged_info = MergeInformationRules(extra_info).transform(last_entity.information)
             if not last_entity.dms:
                 return merged_info, None
+
             extra_dms = InformationToDMS(reserved_properties="warning").transform(extra_info)
+
             merged_dms = MergeDMSRules(extra_dms).transform(last_entity.dms)
             return merged_info, merged_dms