cognite-neat 0.109.2__py3-none-any.whl → 0.109.3__py3-none-any.whl

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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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
 

cognite/neat/_session/_create.py

@@ -3,6 +3,7 @@ from typing import Literal
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat._issues import IssueList
+from cognite.neat._rules.models import DMSRules, InformationRules
 from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
     IncludeReferenced,
@@ -38,22 +39,27 @@ class CreateAPI:
             org_name: Organization name to use for the views in the enterprise data model.
             dummy_property: The dummy property to use as placeholder for the views in the new data model.
 
+        What does this function do?
+            1. It creates a new view for each view in the current data model that implements the view it is based on.
+            2. If dummy_property is set, it will create a container with one property for each view and connect the
+               view to the container.
+            3. It will repeat all connection properties in the new views and update the ValueTypes to match the new
+               views.
+
         !!! note "Enterprise Data Model Creation"
 
             Always create an enterprise data model from a Cognite Data Model as this will
             assure all the Cognite Data Fusion applications to run smoothly, such as
                 - Search
                 - Atlas AI
-                - ...
-
-        !!! note "Move Connections"
-
-            If you want to move the connections to the new data model, set the move_connections
-            to True. This will move the connections to the new data model and use new model
-            views as the source and target views.
+                - Infield
+                - Canvas
+                - Maintain
+                - Charts
 
         """
-        return self._state.rule_transform(
+        last_rules = self._get_last_rules()
+        issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
@@ -61,6 +67,15 @@ class CreateAPI:
                 move_connections=True,
             )
         )
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues
+
+    def _get_last_rules(self) -> InformationRules | DMSRules | None:
+        if not self._state.rule_store.provenance:
+            return None
+        last_entity = self._state.rule_store.provenance[-1].target_entity
+        return last_entity.dms or last_entity.information
 
     def solution_model(
         self,
@@ -76,6 +91,13 @@ class CreateAPI:
                 and the enterprise data model.
             view_prefix: The prefix to use for the views in the enterprise data model.
 
+        What does this function do?
+        1. It will create two new views for each view in the current data model. The first view will be read-only and
+           prefixed with the 'view_prefix'. The second view will be writable and have one property that connects to the
+           read-only view named 'direct_property'.
+        2. It will repeat all connection properties in the new views and update the ValueTypes to match the new views.
+        3. Each writable view will have a container with the single property that connects to the read-only view.
+
         !!! note "Solution Data Model Mode"
 
             The read-only solution model will only be able to read from the existing containers
@@ -88,7 +110,8 @@ class CreateAPI:
             the containers in the solution data model space.
 
         """
-        return self._state.rule_transform(
+        last_rules = self._get_last_rules()
+        issues = self._state.rule_transform(
             ToSolutionModel(
                 new_model_id=data_model_id,
                 properties="connection",
@@ -96,24 +119,32 @@ class CreateAPI:
                 view_prefix=view_prefix,
             )
         )
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues
 
     def data_product_model(
         self,
         data_model_id: DataModelIdentifier,
         include: Literal["same-space", "all"] = "same-space",
-    ) -> None:
+    ) -> IssueList:
         """Uses the current data model as a basis to create data product data model.
 
         A data product model is a data model that ONLY maps to containers and do not use implements. This is
         typically used for defining the data in a data product.
 
+        What does this function do?
+        1. It creates a new view for each view in the current data model. The new views uses the same filter
+           as the view it is based on.
+        2. It will repeat all connection properties in the new views and update the ValueTypes to match the new views.
+
         Args:
             data_model_id: The data product data model id that is being created.
             include: The views to include in the data product data model. Can be either "same-space" or "all".
                 If you set same-space, only the properties of the views in the same space as the data model
                 will be included.
         """
-
+        last_rules = self._get_last_rules()
         view_ids, container_ids = DMSValidation(
             self._state.rule_store.last_verified_dms_rules
         ).imported_views_and_containers_ids()
@@ -130,4 +161,7 @@ class CreateAPI:
 
         transformers.append(ToDataProductModel(new_model_id=data_model_id, include=include))
 
-        self._state.rule_transform(*transformers)
+        issues = self._state.rule_transform(*transformers)
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues

cognite/neat/_session/_prepare.py

@@ -3,6 +3,7 @@ from typing import Any
 
 from rdflib import URIRef
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._graph.transformers import (
     ConnectionToLiteral,
     ConvertLiteral,
@@ -12,9 +13,7 @@ from cognite.neat._graph.transformers import (
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._rules.transformers import (
-    PrefixEntities,
-)
+from cognite.neat._rules.transformers import PrefixEntities, StandardizeNaming
 from cognite.neat._utils.text import humanize_collection
 
 from ._state import SessionState
@@ -264,3 +263,12 @@ class DataModelPrepareAPI:
         """
 
         return self._state.rule_transform(PrefixEntities(prefix))  # type: ignore[arg-type]
+
+    def standardize_naming(self) -> IssueList:
+        """Standardize the naming of all views/classes/properties in the data model.
+
+        For classes/views/containers, the naming will be standardized to PascalCase.
+        For properties, the naming will be standardized to camelCase.
+        """
+        AlphaFlags.standardize_naming.warn()
+        return self._state.rule_transform(StandardizeNaming())

cognite/neat/_session/_state.py

@@ -78,7 +78,7 @@ class InstancesState:
         self.outcome = UploadResultList()
 
         # Ensure that error handling is done in the constructor
-        self.store = _session_method_wrapper(self._create_store, "NeatSession")()
+        self.store: NeatGraphStore = _session_method_wrapper(self._create_store, "NeatSession")()
 
         if self.storage_path:
             print("Remember to close neat session .close() once you are done to avoid oxigraph lock.")

cognite/neat/_session/_to.py

@@ -46,9 +46,9 @@ class ToAPI:
             include_reference: If True, the reference data model will be included. Defaults to True.
                 Note that this only applies if you have created the data model using the
                 create.enterprise_model(...), create.solution_model(), or create.data_product_model() methods.
-        include_properties: The properties to include in the Excel file. Defaults to "all".
-            - "same-space": Only properties that are in the same space as the data model will be included.
-        add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
+            include_properties: The properties to include in the Excel file. Defaults to "all".
+                - "same-space": Only properties that are in the same space as the data model will be included.
+            add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
 
         Example:
             Export information model to excel rules sheet

cognite/neat/_utils/text.py

@@ -17,21 +17,23 @@ def to_camel(string: str) -> str:
         >>> to_camel("ScenarioInstance_priceForecast")
         'scenarioInstancePriceForecast'
     """
+    string = re.sub(r"[\s_-]", "_", string)
+    string = re.sub("_+", "_", string)
     if "_" in string:
-        # Could be a combination of snake and pascal/camel case
-        parts = string.split("_")
-        pascal_splits = [to_pascal(subpart) for part in parts for subpart in part.split("-") if subpart]
-    elif "-" in string:
-        # Could be a combination of kebab and pascal/camel case
-        parts = string.split("-")
-        pascal_splits = [to_pascal(subpart) for part in parts for subpart in part.split("_") if subpart]
+        pascal_splits = [to_pascal(part) for part in string.split("_")]
     else:
-        # Assume is pascal/camel case
         # Ensure pascal
         string = string[0].upper() + string[1:]
         pascal_splits = [string]
-    string_split = []
+    cleaned: list[str] = []
     for part in pascal_splits:
+        if part.upper() == part:
+            cleaned.append(part.capitalize())
+        else:
+            cleaned.append(part)
+
+    string_split = []
+    for part in cleaned:
         string_split.extend(re.findall(r"[A-Z][a-z0-9]*", part))
     if not string_split:
         string_split = [string]
@@ -135,3 +137,32 @@ def humanize_collection(collection: Collection[Any], /, *, sort: bool = True) ->
         sequence = list(strings)
 
     return f"{', '.join(sequence[:-1])} and {sequence[-1]}"
+
+
+class NamingStandardization:
+    _clean_pattern = re.compile(r"[^a-zA-Z0-9_]+")
+    _multi_underscore_pattern = re.compile(r"_+")
+    _start_letter_pattern = re.compile(r"^[a-zA-Z]")
+
+    @classmethod
+    def standardize_class_str(cls, raw: str) -> str:
+        clean = cls._clean_string(raw)
+        if not cls._start_letter_pattern.match(clean):
+            # Underscore ensure that 'Class' it treated as a separate word
+            # in the to_pascale function
+            clean = f"Class_{clean}"
+        return to_pascal(clean)
+
+    @classmethod
+    def standardize_property_str(cls, raw: str) -> str:
+        clean = cls._clean_string(raw)
+        if not cls._start_letter_pattern.match(clean):
+            # Underscore ensure that 'property' it treated as a separate word
+            # in the to_camel function
+            clean = f"property_{clean}"
+        return to_camel(clean)
+
+    @classmethod
+    def _clean_string(cls, raw: str) -> str:
+        raw = cls._clean_pattern.sub("_", raw)
+        return cls._multi_underscore_pattern.sub("_", raw)

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.109.2"
+__version__ = "0.109.3"
 __engine__ = "^2.0.3"

{cognite_neat-0.109.2.dist-info → cognite_neat-0.109.3.dist-info}/METADATA

@@ -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.dist-info → cognite_neat-0.109.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=AXLMIF5t8RmjOpSaIlfqT8ltbPc__Tb8nAVbc1pkE0Q,176
-cognite/neat/_alpha.py,sha256=v-PRdeEikqmm4lHxGAQUOkC7WsySf5X3RPIHQwr2j2o,423
+cognite/neat/_alpha.py,sha256=MXVWltw8esJPFNbLIt74_Xib7z-PXWJOBrTCxK-Z2Qs,483
 cognite/neat/_client/__init__.py,sha256=RQ7MwL8mwGqGHokRzsPqO3XStDzmI4-c12_gz1UPJ74,177
 cognite/neat/_client/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_client/_api/data_modeling_loaders.py,sha256=0BZ5_NeszBvs4DHuHr0cGXytmvkTxrQ8k7v6iaX_mn4,35932
@@ -9,7 +9,7 @@ cognite/neat/_client/data_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 cognite/neat/_client/data_classes/data_modeling.py,sha256=RvpUp9ygd-yffQFJ7O2mQqMLDPIa-dmip5zPb8QVIiw,6672
 cognite/neat/_client/data_classes/neat_sequence.py,sha256=QZWSfWnwk6KlYJvsInco4Wdwc1U8DnOQKWmHebArbQY,10830
 cognite/neat/_client/data_classes/schema.py,sha256=uD8ExxEiIP3zhK4b--Q5fND-vmcC05a9WU5ItLsqG88,23179
-cognite/neat/_client/testing.py,sha256=c5ADJkRJFYGlJVQz-uPqxKExKXT297pxKh_ka4oGBjs,1082
+cognite/neat/_client/testing.py,sha256=M5WUzi3YbtZAN22TXas0SjvMSxmjPFT5m3lNwR0MVkI,1077
 cognite/neat/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
 cognite/neat/_constants.py,sha256=OStolbvP16sM9LltZG6irG27W1tioNGwVr84-Hv6Ovk,5752
 cognite/neat/_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,13 +55,13 @@ cognite/neat/_graph/transformers/_prune_graph.py,sha256=X9wVOBl3mhcPB-SSqWvJHV1h
 cognite/neat/_graph/transformers/_rdfpath.py,sha256=KLNnuLmeMCobJ6Q81l5kUqUt_fkKAovzuiy9zO97sTI,5003
 cognite/neat/_graph/transformers/_value_type.py,sha256=wsuiIKHG6O8F7PaedicMfynTxiVpLZ55zwVU3mCDEYw,15679
 cognite/neat/_issues/__init__.py,sha256=OVgWivp_Br31p8zPeHjOEXs-Wj7lJU1pU1L3pfhfuqE,518
-cognite/neat/_issues/_base.py,sha256=vV0E8cfXKlOnRXFIDZKg5QPMruELEbCaUfQ01l5dR9A,20073
-cognite/neat/_issues/errors/__init__.py,sha256=kwEuvUo9ihxDiONOjlpyLtFTfqviaXR97OJJS-176fs,2282
+cognite/neat/_issues/_base.py,sha256=fZODjRPyiZjVj1ujqKVQOrTh8SaliR9ayG0zRRmyptc,21044
+cognite/neat/_issues/errors/__init__.py,sha256=05PgHRvAwMX9FPRLyAhzOvSXL-JCOs1SqtJGUB975fk,2046
 cognite/neat/_issues/errors/_external.py,sha256=KrF0_ubXlyd903ARUFZlBI45Y-I3q2FS8vSWb9t4WBI,2043
-cognite/neat/_issues/errors/_general.py,sha256=zwEoaygHA2Nt9vCwiveDuzJsqZYIaX0BoUYkwJkQ4jU,844
+cognite/neat/_issues/errors/_general.py,sha256=MnBm9V1S-Agr9kUfTMvviBB4_NkuOXamlgJCu2UojEM,849
 cognite/neat/_issues/errors/_properties.py,sha256=T_nquQeEQS3DQY--DQ13acxhGX_-gpUMjWGTBKCh6r8,2536
 cognite/neat/_issues/errors/_resources.py,sha256=qndhGGPdulWpU7G4PkFHsF4Bjflf3lehGV4A0l-BeNI,3966
-cognite/neat/_issues/errors/_workflow.py,sha256=m_Hlsvl5A1Oy7P3IROnz-4_do8_orZ1Pr1IHqsMyEys,971
+cognite/neat/_issues/errors/_wrapper.py,sha256=e7Zrj7YkzjwS_T880Bh4r0gwstCjU8256_-2A5MA-iA,239
 cognite/neat/_issues/formatters.py,sha256=ziNWT_YXwovTfU8Av5iYuSLgszzJYKTawM_z67VBdlU,3331
 cognite/neat/_issues/warnings/__init__.py,sha256=1iYRzwaMftwcueiA8KMA_bGdxdWxmSfMRqUPeTmHV_w,2909
 cognite/neat/_issues/warnings/_external.py,sha256=O5GSRmIsAC6HyToQ7itpFFNILWCAg0OehPTVUy8pTuc,1319
@@ -108,19 +108,19 @@ cognite/neat/_rules/importers/_yaml2rules.py,sha256=k2oDgz--mxFVeyqQG3uvyYcb0BkF
 cognite/neat/_rules/models/__init__.py,sha256=tf6tyWiYO0eC2PHCcpy208dwOHjEi9hg0sEaQLcB3uA,1024
 cognite/neat/_rules/models/_base_input.py,sha256=kAVI6QYAzsgQ79eLPc_hANJjl-o1e9IKeD7lF61ru9Y,6656
 cognite/neat/_rules/models/_base_rules.py,sha256=TpDhGaodzfzfyrSGChx76Tw_zN2YvtxqFz2lvOMHFPE,15134
-cognite/neat/_rules/models/_rdfpath.py,sha256=hqUMZCMeI8ESdJltu7FifuUhna5JNN_Heup2aYkV56Y,11882
-cognite/neat/_rules/models/_types.py,sha256=gGRS8qK3Z-2buBmYtaVj8762qPNz_ToYAChZYCm8eyE,5381
+cognite/neat/_rules/models/_rdfpath.py,sha256=clZGAzulIFKV2rzwoVZpLRlQUEyrAaiM7SjOoj1KUnY,11948
+cognite/neat/_rules/models/_types.py,sha256=6fHLiVPRlk5QsFjmvDFFqw1htPcPp-RfnUzYoMWNfeg,5418
 cognite/neat/_rules/models/data_types.py,sha256=LJuWUbStlZM4hUJGExOJIJXmAA4uiA0tvO9zKqLUrQg,9805
 cognite/neat/_rules/models/dms/__init__.py,sha256=fRaUH0IwG0YwWd_DNKM6j-jHHFyiIVz4_8DPiS1KR0Y,695
 cognite/neat/_rules/models/dms/_exporter.py,sha256=WFDhkFeY2kJCguru-btcvjDcbMG5ISIAQzIUtDjIlxQ,28097
-cognite/neat/_rules/models/dms/_rules.py,sha256=GhmVmm9vV-CR3uEPzdA_vJbM_EjWVPN_eQmpwVZ4J6Y,22001
+cognite/neat/_rules/models/dms/_rules.py,sha256=VK8QKLf6NxeoaMci5g7EG08XKzSKJZYJwP4wZxa5eUQ,20507
 cognite/neat/_rules/models/dms/_rules_input.py,sha256=noSpYjHKW_GMaeuADOG-Z21ClxiD_tIGxl-dxOKxk-g,13390
 cognite/neat/_rules/models/dms/_validation.py,sha256=PNFHsDNHJZfbHY1qt6D4t3eFOGjqe6Koa702Gzcz0I8,27734
 cognite/neat/_rules/models/entities/__init__.py,sha256=Hlucp3LyV6ncLl79aqRTbSy2qgiGzoyN8x54D_zaJCY,1469
-cognite/neat/_rules/models/entities/_constants.py,sha256=ToiLaaF-hGLPfn3AsKIIrfB4ZdTk4cY1RjM9gA1Qjkg,288
+cognite/neat/_rules/models/entities/_constants.py,sha256=g52-pFP_Qghp86NYk76pLDM52b3T4MXMztxhpeDW3Oc,344
 cognite/neat/_rules/models/entities/_loaders.py,sha256=jFllRty5XpS6uLklr9wJkx7Bzm-qwg65um6hnVistvw,2728
 cognite/neat/_rules/models/entities/_multi_value.py,sha256=6j-nlUA392yQP_uB_CFB6_qFReNhi54ZlbFTcOKpbKY,2755
-cognite/neat/_rules/models/entities/_single_value.py,sha256=GW1R8ko1vwjGhAs2Fl5BGgpz3qtiYnYoahT4hBgJdkA,19441
+cognite/neat/_rules/models/entities/_single_value.py,sha256=XZA4rqXzL-97bsCEAz1imUtn4lir_ikiBfs5LVtziSI,19604
 cognite/neat/_rules/models/entities/_types.py,sha256=df9rnXJJKciv2Bp-Ve2q4xdEJt6WWniq12Z0hW2d6sk,1917
 cognite/neat/_rules/models/entities/_wrapped.py,sha256=SpXIpglXBgaZt6geRparCWdY2F6SH0Fy99fcnA8x8Uk,7648
 cognite/neat/_rules/models/information/__init__.py,sha256=lV7l8RTfWBvN_DFkzea8OzADjq0rZGgWe_0Fiwtfje0,556
@@ -130,25 +130,25 @@ cognite/neat/_rules/models/information/_validation.py,sha256=HbaLShj6uumu-t9I3FU
 cognite/neat/_rules/models/mapping/__init__.py,sha256=T68Hf7rhiXa7b03h4RMwarAmkGnB-Bbhc1H07b2PyC4,100
 cognite/neat/_rules/models/mapping/_classic2core.py,sha256=AhLWoXk4PlBVA6SgBtY9dcLcpqEMaYcsiEatI19miPk,1211
 cognite/neat/_rules/models/mapping/_classic2core.yaml,sha256=jodkmcTborWJmG3At16OChtnol696X6D4lgAa7aaQ78,20491
-cognite/neat/_rules/transformers/__init__.py,sha256=RdpV98nHB_fmkJ8MPKuWuQ5AzSc67oHB5d03D0MBFHk,1291
+cognite/neat/_rules/transformers/__init__.py,sha256=S6iUB7wpAh-7uF5k_EgXT4cGfi8ok5lczGemVxgKckQ,1413
 cognite/neat/_rules/transformers/_base.py,sha256=9LnjKbYIf9238PQXedkTZsMXAyEND6glUD187iEaHfc,2783
-cognite/neat/_rules/transformers/_converters.py,sha256=dmw48thBYHFAaFmT9saD53PSBcTtjXDhKpKzVSlFJgk,66886
+cognite/neat/_rules/transformers/_converters.py,sha256=daDpW4zgHRjm845R2ajfC9XoAPFV2jOq8Wa3z6C4y0M,77621
 cognite/neat/_rules/transformers/_mapping.py,sha256=lf-RKN__5Bg3-tZjEOCa1Sf_JtM_ScQ_TYcnciEnaYQ,18189
 cognite/neat/_rules/transformers/_verification.py,sha256=jKTppklUCVwVlRfYyMfnUtV8r2ACTY-AtsoMF6L-KXo,4593
 cognite/neat/_session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/_session/_base.py,sha256=WEAvz1b9Q8LsPOozLEUEOWLh9XWn1EtxwHw774qLi3E,11744
+cognite/neat/_session/_base.py,sha256=lNCjSiQIn1hI3zSru1hXGTQ0nVzy3CcXTO7vL4XRzno,11935
 cognite/neat/_session/_collector.py,sha256=RcOGY0DjTCCKJt9j_p0gnQXn4omhsIX2G8Aq3ZFHIt4,4218
-cognite/neat/_session/_create.py,sha256=NATzf_5u2aYKXiBmDfNCrcdzQjQsE71XPi--f_iNGcE,5239
+cognite/neat/_session/_create.py,sha256=doDCbDIWMbHCYe3cyk1obQaFdYJjvARg3X4lRUVicCk,7214
 cognite/neat/_session/_drop.py,sha256=gOkDAnddASpFxYxkPjlTyhkpNfnmDEj94GRI8tnHFR0,4167
 cognite/neat/_session/_fix.py,sha256=gpmbJ4TbB_v2nw4fEA2Qtf0ifO3UDEMHGdztha28S_U,898
 cognite/neat/_session/_inspect.py,sha256=VkmDfIjh49NPS8wNa1OdWqhW-oJy1EvMDhKiooMvcjI,9040
 cognite/neat/_session/_mapping.py,sha256=AkQwmqYH-0EgqoXHqCFwJY92hNSGzfojOelhVFlqH4c,2655
-cognite/neat/_session/_prepare.py,sha256=WoVp2Go2RnVaL2RvnCE2-X1kS4ZWxvupOlOmWTce0i0,11626
+cognite/neat/_session/_prepare.py,sha256=fozBTqF8hUTfOf4wzDDulc0Fi5bDfO1C1EeBU0Bii3Q,12088
 cognite/neat/_session/_read.py,sha256=V2F7InkvIODdML7jy4aGXH4PE91tWFzIGcNzOWnsTvM,22514
 cognite/neat/_session/_set.py,sha256=ZYR5G97fi-y68edbG-ftLqM_FRtn9G8V5zDtpslR9go,4070
 cognite/neat/_session/_show.py,sha256=3hUMWBlHCyMiVTbX1GmpVFfthpv3yBIZ293aU0mDxZ8,15156
-cognite/neat/_session/_state.py,sha256=gDyt2gf2kuiHu42zDMO-Pg0zjRllEKC4O8lJ0pMGCkU,4059
-cognite/neat/_session/_to.py,sha256=w7ukhG0cjkKlMPhhivaL5Poq4W_-p8ZEWQSWuVnQGiw,11670
+cognite/neat/_session/_state.py,sha256=udCCS5tWA2z7P1YK65iyC-weDwgQg07P_MS3TLjJC90,4075
+cognite/neat/_session/_to.py,sha256=Wls8Obfx4Aodgyf_8jq7HxPt8JSHoFQ-DhJIfVoe3JU,11682
 cognite/neat/_session/_wizard.py,sha256=9idlzhZy54h2Iwupe9iXKX3RDb5jJQuBZFEouni50L0,1476
 cognite/neat/_session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvca6n48bu_bI,120
 cognite/neat/_session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
@@ -171,14 +171,14 @@ cognite/neat/_utils/rdf_.py,sha256=b3sE3aTW9lu4gJWQJEaq_NCLbI54cc1o12utz-xbLh8,9
 cognite/neat/_utils/reader/__init__.py,sha256=fPkrNB_9hLB7CyHTCFV_xEbIfOMqUQzNly5JN33-QfM,146
 cognite/neat/_utils/reader/_base.py,sha256=Q35hz8tqAiQiELjE4DsDDKQHLtRmSTrty4Gep9rg_CU,5444
 cognite/neat/_utils/spreadsheet.py,sha256=20L_44m0hg3UdBFwCxnmAravxvCOolNZwVOGHfjYGR4,3089
-cognite/neat/_utils/text.py,sha256=0IffvBIAmeGh92F4T6xiEdd-vv3B7FOGEMbfuTktO5Y,4017
+cognite/neat/_utils/text.py,sha256=9sBlE05S_9irzRxRvafBlWWy-kPgvUPV2Xo-_IgcwHM,4944
 cognite/neat/_utils/time_.py,sha256=O30LUiDH9TdOYz8_a9pFqTtJdg8vEjC3qHCk8xZblG8,345
 cognite/neat/_utils/upload.py,sha256=iWKmsQgw4EHLv-11NjYu7zAj5LtqTAfNa87a1kWeuaU,5727
 cognite/neat/_utils/xml_.py,sha256=FQkq84u35MUsnKcL6nTMJ9ajtG9D5i1u4VBnhGqP2DQ,1710
-cognite/neat/_version.py,sha256=C9cGHhgqgxsB1rbURMXLvpzrANgFHbmOFq3MJSffn3w,46
+cognite/neat/_version.py,sha256=vGciJru9VsVwxQTbuUK6fhVtm7NFfhyVTVYsHrCWLes,46
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-0.109.2.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.109.2.dist-info/METADATA,sha256=lskGgPFezWb9blta8e5kdLXvTROMUKyMpVxrh8yIQvI,5361
-cognite_neat-0.109.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-cognite_neat-0.109.2.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
-cognite_neat-0.109.2.dist-info/RECORD,,
+cognite_neat-0.109.3.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.109.3.dist-info/METADATA,sha256=gB5oGvRGY4ON3W-z80mUOHMVSOlilQy3zUMLhqGJrhg,5361
+cognite_neat-0.109.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+cognite_neat-0.109.3.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
+cognite_neat-0.109.3.dist-info/RECORD,,

cognite/neat/_issues/errors/_workflow.py

@@ -1,36 +0,0 @@
-from dataclasses import dataclass
-
-from cognite.neat._issues import NeatError
-
-
-@dataclass(unsafe_hash=True)
-class WorkFlowMissingDataError(NeatError, ValueError):
-    """In the workflow step {step_name} the following data is missing: {missing_data}."""
-
-    step_name: str
-    missing_data: frozenset[str]
-
-
-@dataclass(unsafe_hash=True)
-class WorkflowStepNotInitializedError(NeatError, RuntimeError):
-    """Step {step_name} has not been initialized."""
-
-    step_name: str
-
-
-@dataclass(unsafe_hash=True)
-class WorkflowConfigurationNotSetError(NeatError, RuntimeError):
-    """The configuration variable '{config_variable}' is not set. Please set the configuration
-    before running the workflow."""
-
-    config_variable: str
-
-
-@dataclass(unsafe_hash=True)
-class WorkflowStepOutputError(NeatError, RuntimeError):
-    """Object type {step_type} is not supported as step output.
-
-    Step output must be of type DataContract or a FlowMessage.
-    """
-
-    step_type: str