cognite-neat 0.117.12__py3-none-any.whl → 0.119.0__py3-none-any.whl

cognite/neat/_alpha.py

@@ -22,3 +22,4 @@ class ExperimentalFlags:
     aml_read = ExperimentalFeatureWarning("aml_read")
     csv_read = ExperimentalFeatureWarning("csv_read")
     to_ontology = ExperimentalFeatureWarning("to_ontology")
+    extension = ExperimentalFeatureWarning("extension")

cognite/neat/_rules/analysis/_base.py

@@ -154,8 +154,12 @@ class RulesAnalysis:
     def _include_ancestors(parents_by_class: dict[T_Hashable, set[T_Hashable]]) -> None:
         # Topological sort to ensure that classes include all ancestors
         for class_entity in list(TopologicalSorter(parents_by_class).static_order()):
+            if class_entity not in parents_by_class:
+                continue
             parents_by_class[class_entity] |= {
-                grand_parent for parent in parents_by_class[class_entity] for grand_parent in parents_by_class[parent]
+                grand_parent
+                for parent in parents_by_class[class_entity]
+                for grand_parent in parents_by_class.get(parent, set())
             }
 
     def properties_by_class(

cognite/neat/_rules/importers/_dms2rules.py

@@ -1,8 +1,9 @@
+import warnings
 from collections import defaultdict
 from collections.abc import Collection, Iterable, Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Literal, cast
+from typing import Literal
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
@@ -16,8 +17,13 @@ from cognite.client.data_classes.data_modeling.data_types import Enum as DMSEnum
 from cognite.client.data_classes.data_modeling.views import (
     MultiEdgeConnectionApply,
     MultiReverseDirectRelationApply,
+    ReverseDirectRelation,
+    SingleEdgeConnection,
     SingleEdgeConnectionApply,
+    SingleReverseDirectRelation,
     SingleReverseDirectRelationApply,
+    View,
+    ViewProperty,
     ViewPropertyApply,
 )
 from cognite.client.utils import ms_to_datetime
@@ -28,11 +34,13 @@ from cognite.neat._issues import IssueList, MultiValueError, NeatIssue, catch_is
 from cognite.neat._issues.errors import (
     FileTypeUnexpectedError,
     NeatValueError,
+    PropertyTypeNotSupportedError,
     ResourceMissingIdentifierError,
     ResourceRetrievalError,
 )
 from cognite.neat._issues.warnings import (
     MissingCogniteClientWarning,
+    NeatValueWarning,
     PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNotFoundWarning,
@@ -45,7 +53,7 @@ from cognite.neat._rules.models import (
     DMSInputRules,
     DMSSchema,
 )
-from cognite.neat._rules.models.data_types import DataType, Enum
+from cognite.neat._rules.models.data_types import DataType, Enum, String
 from cognite.neat._rules.models.dms import (
     DMSInputContainer,
     DMSInputEnum,
@@ -63,6 +71,10 @@ from cognite.neat._rules.models.entities import (
     ReverseConnectionEntity,
     ViewEntity,
 )
+from cognite.neat._rules.models.information import (
+    InformationInputClass,
+    InformationInputProperty,
+)
 
 
 class DMSImporter(BaseImporter[DMSInputRules]):
@@ -332,19 +344,27 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             )
             return None
 
-        value_type = self._get_value_type(prop, view_entity, prop_id, enum_collection_by_container_property)
+        container_property = (
+            self._get_container_property_definition(prop) if isinstance(prop, dm.MappedPropertyApply) else None
+        )
+        value_type = self._get_value_type(prop, container_property, enum_collection_by_container_property)
         if value_type is None:
+            self.issue_list.append(
+                PropertyTypeNotSupportedWarning(view_entity.as_id(), "view", prop_id, type(prop).__name__)
+            )
             return None
+        if isinstance(value_type, ViewEntity) and value_type.as_id() not in self._all_views_by_id:
+            self.issue_list.append(ResourceUnknownWarning(prop.source, "view", view_entity.as_id(), "view"))
 
         return DMSInputProperty(
             description=prop.description,
             name=prop.name,
             connection=self._get_connection_type(prop),
             value_type=str(value_type),
-            min_count=self._get_min_count(prop),
-            max_count=self._get_max_count(prop),
+            min_count=self._get_min_count(prop, container_property),
+            max_count=self._get_max_count(prop, container_property),
             immutable=self._get_immutable(prop),
-            default=self._get_default(prop),
+            default=self._get_default(prop, container_property),
             container=(
                 str(ContainerEntity.from_id(prop.container)) if isinstance(prop, dm.MappedPropertyApply) else None
             ),
@@ -357,7 +377,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             constraint=self._get_constraint(prop, prop_id),
         )
 
-    def _container_prop_unsafe(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
+    def _get_container_property_definition(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
         """This method assumes you have already checked that the container with property exists."""
         return self._all_containers_by_id[prop.container].properties[prop.container_property_identifier]
 
@@ -372,40 +392,48 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         elif isinstance(prop, SingleReverseDirectRelationApply | MultiReverseDirectRelationApply):
             return ReverseConnectionEntity(property=prop.through.property)
         elif isinstance(prop, dm.MappedPropertyApply) and isinstance(
-            self._container_prop_unsafe(prop).type, dm.DirectRelation
+            self._get_container_property_definition(prop).type, dm.DirectRelation
         ):
             return "direct"
         else:
             return None
 
+    @classmethod
     def _get_value_type(
-        self,
-        prop: ViewPropertyApply,
-        view_entity: ViewEntity,
-        prop_id: str,
-        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str],
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str] | None = None,
     ) -> DataType | ViewEntity | DMSUnknownEntity | None:
         if isinstance(
             prop,
             SingleEdgeConnectionApply
             | MultiEdgeConnectionApply
             | SingleReverseDirectRelationApply
-            | MultiReverseDirectRelationApply,
+            | MultiReverseDirectRelationApply
+            | SingleEdgeConnection
+            | dm.MultiEdgeConnection
+            | SingleReverseDirectRelation
+            | dm.MultiReverseDirectRelation,
         ):
             return ViewEntity.from_id(prop.source)
-        elif isinstance(prop, dm.MappedPropertyApply):
-            container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
-            if isinstance(container_prop.type, dm.DirectRelation):
+        elif isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("container property must be provided when prop is a MappedProperty")
+                prop_type = container_property.type
+            else:
+                prop_type = prop.type
+            if isinstance(prop_type, dm.DirectRelation):
                 if prop.source is None:
                     return DMSUnknownEntity()
-                elif prop.source not in self._all_views_by_id:
-                    self.issue_list.append(ResourceUnknownWarning(prop.source, "view", view_entity.as_id(), "view"))
-                    return ViewEntity.from_id(prop.source)
                 else:
                     return ViewEntity.from_id(prop.source)
-            elif isinstance(container_prop.type, PropertyTypeWithUnit) and container_prop.type.unit:
-                return DataType.load(f"{container_prop.type._type}(unit={container_prop.type.unit.external_id})")
-            elif isinstance(container_prop.type, DMSEnum):
+            elif isinstance(prop_type, PropertyTypeWithUnit) and prop_type.unit:
+                return DataType.load(f"{prop_type._type}(unit={prop_type.unit.external_id})")
+            elif isinstance(prop_type, DMSEnum):
+                if enum_collection_by_container_property is None:
+                    return String()
                 collection = enum_collection_by_container_property.get(
                     (prop.container, prop.container_property_identifier)
                 )
@@ -415,30 +443,46 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                         f"BUG in Neat: Enum for {prop.container}.{prop.container_property_identifier} not found."
                     )
 
-                return Enum(collection=ClassEntity(suffix=collection), unknownValue=container_prop.type.unknown_value)
+                return Enum(collection=ClassEntity(suffix=collection), unknownValue=prop_type.unknown_value)
             else:
-                return DataType.load(container_prop.type._type)
+                return DataType.load(prop_type._type)
         else:
-            self.issue_list.append(
-                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
-            )
             return None
 
-    def _get_min_count(self, prop: ViewPropertyApply) -> int | None:
+    @classmethod
+    def _get_min_count(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> int | None:
         if isinstance(prop, dm.MappedPropertyApply):
-            return int(not self._container_prop_unsafe(prop).nullable)
+            if container_property is None:
+                raise ValueError("container_property must be provided when prop is a MappedPropertyApply")
+            return int(not container_property.nullable)
+        elif isinstance(prop, dm.MappedProperty):
+            return int(not prop.nullable)
         else:
             return None
 
     def _get_immutable(self, prop: ViewPropertyApply) -> bool | None:
         if isinstance(prop, dm.MappedPropertyApply):
-            return self._container_prop_unsafe(prop).immutable
+            return self._get_container_property_definition(prop).immutable
         else:
             return None
 
-    def _get_max_count(self, prop: ViewPropertyApply) -> int | float | None:
-        if isinstance(prop, dm.MappedPropertyApply):
-            prop_type = self._container_prop_unsafe(prop).type
+    @classmethod
+    def _get_max_count(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> int | float | None:
+        if isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("get_container must be provided when prop is a MappedPropertyApply")
+                prop_type = container_property.type
+            else:
+                prop_type = prop.type
             if isinstance(prop_type, ListablePropertyType):
                 if prop_type.is_list is False:
                     return 1
@@ -450,17 +494,41 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                     return DMS_PRIMITIVE_LIST_DEFAULT_LIMIT
             else:
                 return 1
-        elif isinstance(prop, MultiEdgeConnectionApply | MultiReverseDirectRelationApply):
+        elif isinstance(
+            prop,
+            MultiEdgeConnectionApply
+            | MultiReverseDirectRelationApply
+            | dm.MultiEdgeConnection
+            | dm.MultiReverseDirectRelation,
+        ):
             return float("inf")
-        elif isinstance(prop, SingleEdgeConnectionApply | SingleReverseDirectRelationApply):
+        elif isinstance(
+            prop,
+            SingleEdgeConnectionApply
+            | SingleReverseDirectRelationApply
+            | SingleEdgeConnection
+            | SingleReverseDirectRelation,
+        ):
             return 1
         else:
-            # Unknown type.
+            warnings.warn(
+                NeatValueWarning(f"Unknown property type {type(prop)}. Assuming max count is inf"), stacklevel=2
+            )
             return None
 
-    def _get_default(self, prop: ViewPropertyApply) -> str | None:
-        if isinstance(prop, dm.MappedPropertyApply):
-            default = self._container_prop_unsafe(prop).default_value
+    @classmethod
+    def _get_default(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> str | None:
+        if isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("container_property must be provided when prop is a MappedPropertyApply")
+                default = container_property.default_value
+            else:
+                default = prop.default_value
             if default is not None:
                 return str(default)
         return None
@@ -559,3 +627,43 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                         )
                     )
         return enum_by_container_property
+
+    @classmethod
+    def as_information_input_property(
+        cls, entity: ClassEntity, prop_id: str, view_property: ViewProperty
+    ) -> InformationInputProperty:
+        if not isinstance(view_property, dm.MappedProperty | dm.EdgeConnection | ReverseDirectRelation):
+            raise PropertyTypeNotSupportedError(
+                dm.ViewId(str(entity.prefix), str(entity.suffix), entity.version),
+                "view",
+                prop_id,
+                type(view_property).__name__,
+            )
+
+        value_type = cls._get_value_type(view_property)
+        if value_type is None:
+            raise NeatValueError(f"Failed to get value type for {entity} property {prop_id}")
+
+        return InformationInputProperty(
+            class_=entity,
+            property_=prop_id,
+            value_type=str(value_type),
+            name=view_property.name,
+            description=view_property.description,
+            min_count=cls._get_min_count(view_property),
+            max_count=cls._get_max_count(view_property),
+            default=cls._get_default(view_property),
+        )
+
+    @classmethod
+    def as_information_input_class(cls, view: View) -> InformationInputClass:
+        return InformationInputClass(
+            class_=ClassEntity(prefix=view.space, suffix=view.external_id, version=view.version),
+            name=view.name,
+            description=view.description,
+            implements=[
+                ClassEntity(prefix=parent.space, suffix=parent.external_id, version=parent.version)
+                for parent in view.implements or []
+            ]
+            or None,
+        )

cognite/neat/_rules/models/information/_rules_input.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any
+from typing import Any, cast
 
 import pandas as pd
 from cognite.client import data_modeling as dm
@@ -103,6 +103,9 @@ class InformationInputProperty(InputComponent[InformationProperty]):
         output["Value Type"] = load_value_type(self.value_type, default_prefix)
         return output
 
+    def copy(self, update: dict[str, Any], default_prefix: str) -> "InformationInputProperty":
+        return cast(InformationInputProperty, type(self)._load({**self.dump(default_prefix), **update}))
+
 
 @dataclass
 class InformationInputClass(InputComponent[InformationClass]):

cognite/neat/_rules/transformers/__init__.py

@@ -1,6 +1,7 @@
 from ._base import RulesTransformer, VerifiedRulesTransformer
 from ._converters import (
     AddClassImplements,
+    AddCogniteProperties,
     ChangeViewPrefix,
     ClassicPrepareCore,
     ConversionTransformer,
@@ -29,6 +30,7 @@ from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRule
 
 __all__ = [
     "AddClassImplements",
+    "AddCogniteProperties",
     "AsParentPropertyId",
     "ChangeViewPrefix",
     "ClassicPrepareCore",

cognite/neat/_rules/transformers/_converters.py

@@ -6,10 +6,12 @@ from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
 from functools import cached_property
+from graphlib import CycleError, TopologicalSorter
 from typing import Any, ClassVar, Literal, TypeVar, cast, overload
 
+from cognite.client import data_modeling as dm
 from cognite.client.data_classes import data_modeling as dms
-from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
+from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, View, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 from pydantic import ValidationError
 from rdflib import Namespace
@@ -25,8 +27,10 @@ from cognite.neat._constants import (
     DMS_RESERVED_PROPERTIES,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._issues.warnings import NeatValueWarning
+from cognite.neat._issues import IssueList
+from cognite.neat._issues._factory import from_pydantic_errors
+from cognite.neat._issues.errors import CDFMissingClientError, NeatValueError
+from cognite.neat._issues.warnings import NeatValueWarning, PropertyOverwritingWarning
 from cognite.neat._issues.warnings._models import (
     SolutionModelBuildOnTopOfCDMWarning,
 )
@@ -60,9 +64,16 @@ from cognite.neat._rules.models.entities import (
     UnknownEntity,
     ViewEntity,
 )
-from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
+from cognite.neat._rules.models.information import (
+    InformationClass,
+    InformationInputClass,
+    InformationInputProperty,
+    InformationMetadata,
+    InformationProperty,
+)
 from cognite.neat._utils.rdf_ import get_inheritance_path
-from cognite.neat._utils.text import NamingStandardization, title, to_camel_case, to_words
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
+from cognite.neat._utils.text import NamingStandardization, humanize_collection, title, to_camel_case, to_words
 
 from ._base import RulesTransformer, T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
 from ._verification import VerifyDMSRules
@@ -522,13 +533,17 @@ class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
     def __init__(
-        self, ignore_undefined_value_types: bool = False, reserved_properties: Literal["error", "warning"] = "error"
+        self,
+        ignore_undefined_value_types: bool = False,
+        reserved_properties: Literal["error", "warning"] = "error",
+        client: NeatClient | None = None,
     ):
         self.ignore_undefined_value_types = ignore_undefined_value_types
         self.reserved_properties = reserved_properties
+        self.client = client
 
     def transform(self, rules: InformationRules) -> DMSRules:
-        return _InformationRulesConverter(rules).as_dms_rules(
+        return _InformationRulesConverter(rules, self.client).as_dms_rules(
             self.ignore_undefined_value_types, self.reserved_properties
         )
 
@@ -1347,9 +1362,10 @@ class MergeInformationRules(VerifiedRulesTransformer[InformationRules, Informati
 class _InformationRulesConverter:
     _start_or_end_node: ClassVar[frozenset[str]] = frozenset({"endNode", "end_node", "startNode", "start_node"})
 
-    def __init__(self, information: InformationRules):
+    def __init__(self, information: InformationRules, client: NeatClient | None = None):
         self.rules = information
         self.property_count_by_container: dict[ContainerEntity, int] = defaultdict(int)
+        self.client = client
 
     def as_dms_rules(
         self, ignore_undefined_value_types: bool = False, reserved_properties: Literal["error", "warning"] = "error"
@@ -1388,9 +1404,29 @@ class _InformationRulesConverter:
             and (prop.property_ == "endNode" or prop.property_ == "end_node")
             and isinstance(prop.value_type, ClassEntity)
         }
+        ancestors_by_view: dict[ViewEntity, set[ViewEntity]] = {}
+        parents_by_class = RulesAnalysis(self.rules).parents_by_class(
+            include_ancestors=True, include_different_space=True
+        )
+        for cls_, parents in parents_by_class.items():
+            view_type = cls_.as_view_entity(default_space, default_version)
+            parent_views = {parent.as_view_entity(default_space, default_version) for parent in parents}
+            if view_type in ancestors_by_view:
+                ancestors_by_view[view_type].update(parent_views)
+            else:
+                ancestors_by_view[view_type] = parent_views
+
+        cognite_properties, cognite_containers, cognite_views = self._get_cognite_components()
+        for view in cognite_views:
+            if view in ancestors_by_view:
+                ancestors_by_view[view].update(cognite_views[view])
+            else:
+                ancestors_by_view[view] = cognite_views[view]
 
         properties_by_class: dict[ClassEntity, list[DMSProperty]] = defaultdict(list)
-        referenced_containers: dict[ContainerEntity, Counter[ClassEntity]] = defaultdict(Counter)
+        used_containers: dict[ContainerEntity, Counter[ClassEntity]] = defaultdict(Counter)
+        used_cognite_containers: dict[ContainerEntity, DMSContainer] = {}
+
         for prop in self.rules.properties:
             if ignore_undefined_value_types and isinstance(prop.value_type, UnknownEntity):
                 continue
@@ -1403,17 +1439,34 @@ class _InformationRulesConverter:
                 warnings.warn(NeatValueWarning(f"{msg} Skipping..."), stacklevel=2)
                 continue
 
-            dms_property = self._as_dms_property(
-                prop,
-                default_space,
-                default_version,
-                edge_classes,
-                edge_value_types_by_class_property_pair,
-                end_node_by_edge,
-            )
+            if cognite_property := self._find_cognite_property(
+                prop.property_, parents_by_class[prop.class_], cognite_properties
+            ):
+                dms_property = self._customize_cognite_property(
+                    prop,
+                    cognite_property,
+                    prop.class_,
+                    default_space,
+                    default_version,
+                    ancestors_by_view,
+                )
+                if dms_property.container:
+                    if dms_property.container not in used_cognite_containers:
+                        used_cognite_containers[dms_property.container] = cognite_containers[dms_property.container]
+            else:
+                # Not matching any parent.
+                dms_property = self._as_dms_property(
+                    prop,
+                    default_space,
+                    default_version,
+                    edge_classes,
+                    edge_value_types_by_class_property_pair,
+                    end_node_by_edge,
+                )
+                if dms_property.container:
+                    used_containers[dms_property.container][prop.class_] += 1
+
             properties_by_class[prop.class_].append(dms_property)
-            if dms_property.container:
-                referenced_containers[dms_property.container][prop.class_] += 1
 
         views: list[DMSView] = []
 
@@ -1433,11 +1486,11 @@ class _InformationRulesConverter:
         existing_containers: set[ContainerEntity] = set()
 
         containers: list[DMSContainer] = []
-        for container_entity, class_entities in referenced_containers.items():
+        for container_entity, class_entities in used_containers.items():
             if container_entity in existing_containers:
                 continue
             constrains = self._create_container_constraint(
-                class_entities, default_space, class_by_entity, referenced_containers
+                class_entities, default_space, class_by_entity, used_containers
             )
             most_used_class_entity = class_entities.most_common(1)[0][0]
             class_ = class_by_entity[most_used_class_entity]
@@ -1458,6 +1511,9 @@ class _InformationRulesConverter:
             )
             containers.append(container)
 
+        if used_cognite_containers:
+            containers.extend(used_cognite_containers.values())
+
         dms_rules = DMSRules(
             metadata=dms_metadata,
             properties=SheetList[DMSProperty]([prop for prop_set in properties_by_class.values() for prop in prop_set]),
@@ -1469,6 +1525,35 @@ class _InformationRulesConverter:
 
         return dms_rules
 
+    def _get_cognite_components(
+        self,
+    ) -> tuple[
+        dict[tuple[ClassEntity, str], DMSProperty],
+        dict[ContainerEntity, DMSContainer],
+        dict[ViewEntity, set[ViewEntity]],
+    ]:
+        cognite_concepts = self._get_cognite_concepts()
+        cognite_properties: dict[tuple[ClassEntity, str], DMSProperty] = {}
+        cognite_containers: dict[ContainerEntity, DMSContainer] = {}
+        cognite_views: dict[ViewEntity, set[ViewEntity]] = {}
+        if cognite_concepts:
+            if self.client is None:
+                raise CDFMissingClientError(
+                    f"Cannot convert {self.rules.metadata.as_data_model_id()}. Missing Cognite Client."
+                    f"This is required as the data model is referencing cognite concepts in the implements"
+                    f"{humanize_collection(cognite_concepts)}"
+                )
+            cognite_rules = self._get_cognite_dms_rules(cognite_concepts, self.client)
+
+            cognite_properties = {
+                (dms_prop.view.as_class(), dms_prop.view_property): dms_prop for dms_prop in cognite_rules.properties
+            }
+            cognite_containers = {container.container: container for container in cognite_rules.containers or []}
+            cognite_views = RulesAnalysis(dms=cognite_rules).implements_by_view(
+                include_ancestors=True, include_different_space=True
+            )
+        return cognite_properties, cognite_containers, cognite_views
+
     @staticmethod
     def _create_container_constraint(
         class_entities: Counter[ClassEntity],
@@ -1563,6 +1648,74 @@ class _InformationRulesConverter:
 
         return dms_property
 
+    @staticmethod
+    def _customize_cognite_property(
+        prop: InformationProperty,
+        cognite_prop: DMSProperty,
+        class_: ClassEntity,
+        default_space: str,
+        default_version: str,
+        ancestors_by_view: dict[ViewEntity, set[ViewEntity]],
+    ) -> DMSProperty:
+        """Customize the cognite property to match the information property.
+        This means updating the name and description of the cognite property with the information property.
+        In addition, the value type can be updated given that the value type is matches the cognite property value
+        type or in the case of a View Value type a derivative of the cognite property value type.
+
+        Args:
+            prop: Information property
+            cognite_prop: Cognite property
+            class_: Class entity
+            default_space: The default space
+            default_version: The default version
+            ancestors_by_view: Ancestors by view
+
+        Returns:
+            DMSProperty: The customized cognite property
+
+        """
+        value_type: DataType | ViewEntity | DMSUnknownEntity = cognite_prop.value_type
+        if isinstance(prop.value_type, DataType) and prop.value_type != value_type:
+            warnings.warn(
+                PropertyOverwritingWarning(prop.property_, "property", "value type", (str(prop.value_type),)),
+                stacklevel=2,
+            )
+        elif isinstance(prop.value_type, DataType):
+            # User set the same value type as core concept.
+            pass
+        elif isinstance(prop.value_type, ClassEntity) and isinstance(cognite_prop.value_type, ViewEntity):
+            view_type = prop.value_type.as_view_entity(default_space, default_version)
+            ancestors = ancestors_by_view.get(view_type, set())
+            if view_type == cognite_prop.value_type or cognite_prop.value_type in ancestors:
+                value_type = view_type
+            else:
+                warnings.warn(
+                    NeatValueWarning(
+                        f"Invalid Value Type. The view {view_type} must implement "
+                        f"{humanize_collection(ancestors, bind_word='or')} "
+                        f"to be used as the Value Type in the {prop.class_!s}.{prop.property_}. "
+                        f"Skipping..."
+                    ),
+                    stacklevel=2,
+                )
+        else:
+            warnings.warn(
+                NeatValueWarning(
+                    f"Invalid Value Type. The {prop.value_type} is not supported as {prop.class_} implements"
+                    f"a cognite concepts. Will skip this, and use the {cognite_prop.value_type} instead."
+                ),
+                stacklevel=2,
+            )
+
+        return cognite_prop.model_copy(
+            update={
+                "view": class_.as_view_entity(default_space, default_version),
+                "name": prop.name or cognite_prop.name,
+                "description": prop.description or cognite_prop.description,
+                "value_type": value_type,
+            }
+        )
+
     @staticmethod
     def _get_connection(
         prop: InformationProperty,
@@ -1703,6 +1856,48 @@ class _InformationRulesConverter:
 
         return data_types.String()
 
+    def _get_cognite_concepts(self) -> set[ClassEntity]:
+        return {cls_.class_ for cls_ in self.rules.classes if str(cls_.class_.prefix) in COGNITE_SPACES} | {
+            parent
+            for cls_ in self.rules.classes
+            for parent in cls_.implements or []
+            if str(parent.prefix) in COGNITE_SPACES
+        }
+
+    @staticmethod
+    def _get_cognite_dms_rules(concepts: set[ClassEntity], client: NeatClient) -> DMSRules:
+        view_ids = [dm.ViewId(str(cls_.prefix), cls_.suffix, cls_.version) for cls_ in concepts]
+        views = client.loaders.views.retrieve(view_ids, format="read", include_connected=True, include_ancestor=True)
+        spaces = Counter(view.space for view in views)
+        space = spaces.most_common(1)[0][0]
+        model: dm.DataModel[dm.View] = dm.DataModel(
+            space=space,
+            external_id="CognitePlaceholderModel",
+            version="v1",
+            is_global=False,
+            last_updated_time=1,
+            created_time=1,
+            name=None,
+            description="This model is constructed to hold all properties/views/containers that are referenced"
+            "by the data model being converted to DMS. This model is not meant to be used for any other"
+            "purpose.",
+            views=list(views),
+        )
+        unverified = DMSImporter.from_data_model(client, model).to_rules()
+        if unverified.rules is None:
+            raise NeatValueError("Failed to create CogniteConcepts")
+        return unverified.rules.as_verified_rules()
+
+    @staticmethod
+    def _find_cognite_property(
+        property_: str, parents: set[ClassEntity], cognite_properties: dict[tuple[ClassEntity, str], DMSProperty]
+    ) -> DMSProperty | None:
+        """Find the parent class that has the property in the cognite properties"""
+        for parent in parents:
+            if (parent, property_) in cognite_properties:
+                return cognite_properties[(parent, property_)]
+        return None
+
 
 class _DMSRulesConverter:
     def __init__(self, dms: DMSRules, instance_namespace: Namespace | None = None) -> None:
@@ -2017,3 +2212,131 @@ class SubsetInformationRules(VerifiedRulesTransformer[InformationRules, Informat
             return InformationRules.model_validate(subsetted_rules)
         except ValidationError as e:
             raise NeatValueError(f"Cannot subset rules: {e}") from e
+
+
+class AddCogniteProperties(RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]):
+    """This transformer looks at the implements of the classes and adds all properties
+    from the parent (and ancestors) classes that are not already included in the data model.
+
+    Args:
+        client: The client is used to look up the properties of the parent classes.
+
+    """
+
+    def __init__(self, client: NeatClient) -> None:
+        self._client = client
+
+    @property
+    def description(self) -> str:
+        """Get the description of the transformer."""
+        return "Add Cognite properties for all concepts that implements a Cognite concept."
+
+    def transform(self, rules: ReadRules[InformationInputRules]) -> ReadRules[InformationInputRules]:
+        input_ = rules.rules
+        if input_ is None:
+            raise NeatValueError("Rule read failed. Cannot add cognite properties to None rules.")
+
+        default_space = input_.metadata.space
+        default_version = input_.metadata.version
+
+        dependencies_by_class = self._get_dependencies_by_class(input_.classes, rules.read_context, default_space)
+        properties_by_class = self._get_properties_by_class(input_.properties, rules.read_context, default_space)
+        cognite_implements_concepts = self._get_cognite_concepts(dependencies_by_class)
+        views_by_class_entity = self._get_views_by_class(cognite_implements_concepts, default_space, default_version)
+
+        for class_entity, view in views_by_class_entity.items():
+            for prop_id, view_prop in view.properties.items():
+                if prop_id in properties_by_class[class_entity]:
+                    continue
+                properties_by_class[class_entity][prop_id] = DMSImporter.as_information_input_property(
+                    class_entity, prop_id, view_prop
+                )
+
+        try:
+            topological_order = TopologicalSorter(dependencies_by_class).static_order()
+        except CycleError as e:
+            raise NeatValueError(f"Cycle detected in the class hierarchy: {e}") from e
+
+        new_properties: list[InformationInputProperty] = input_.properties.copy()
+        for class_entity in topological_order:
+            if class_entity not in dependencies_by_class:
+                continue
+            for parent in dependencies_by_class[class_entity]:
+                for prop in properties_by_class[parent].values():
+                    if prop.property_ not in properties_by_class[class_entity]:
+                        new_prop = prop.copy(update={"Class": class_entity}, default_prefix=default_space)
+                        new_properties.append(new_prop)
+                        properties_by_class[class_entity][prop.property_] = new_prop
+
+        new_classes: list[InformationInputClass] = input_.classes.copy()
+        existing_classes = {cls.class_ for cls in input_.classes}
+        for class_entity, view in views_by_class_entity.items():
+            if class_entity not in existing_classes:
+                new_classes.append(DMSImporter.as_information_input_class(view))
+                existing_classes.add(class_entity)
+
+        return ReadRules(
+            rules=InformationInputRules(
+                metadata=input_.metadata,
+                properties=new_properties,
+                classes=new_classes,
+                prefixes=input_.prefixes,
+            ),
+            read_context={},
+        )
+
+    @staticmethod
+    def _get_properties_by_class(
+        properties: list[InformationInputProperty], read_context: dict[str, SpreadsheetRead], default_space: str
+    ) -> dict[ClassEntity, dict[str, InformationInputProperty]]:
+        issues = IssueList()
+        properties_by_class: dict[ClassEntity, dict[str, InformationInputProperty]] = defaultdict(dict)
+        for prop in properties:
+            try:
+                dumped = prop.dump(default_prefix=default_space)
+            except ValidationError as e:
+                issues.extend(from_pydantic_errors(e.errors(), read_context))
+                continue
+            class_entity = cast(ClassEntity, dumped["Class"])
+            properties_by_class[class_entity][prop.property_] = prop
+        if issues.has_errors:
+            raise issues.as_errors(operation="Reading properties")
+        return properties_by_class
+
+    @staticmethod
+    def _get_dependencies_by_class(
+        classes: list[InformationInputClass], read_context: dict[str, SpreadsheetRead], default_space: str
+    ) -> dict[ClassEntity, set[ClassEntity]]:
+        dependencies_by_class: dict[ClassEntity, set[ClassEntity]] = {}
+        issues = IssueList()
+        for raw in classes:
+            try:
+                dumped = raw.dump(default_prefix=default_space)
+            except ValidationError as e:
+                issues.extend(from_pydantic_errors(e.errors(), read_context))
+                continue
+            class_entity = cast(ClassEntity, dumped["Class"])
+            implements = cast(list[ClassEntity] | None, dumped["Implements"])
+            dependencies_by_class[class_entity] = set(implements or [])
+        if issues.has_errors:
+            raise issues.as_errors(operation="Reading classes")
+        return dependencies_by_class
+
+    @staticmethod
+    def _get_cognite_concepts(dependencies_by_class: dict[ClassEntity, set[ClassEntity]]) -> set[ClassEntity]:
+        cognite_implements_concepts = {
+            dependency
+            for dependencies in dependencies_by_class.values()
+            for dependency in dependencies
+            if dependency.prefix in COGNITE_SPACES
+        }
+        if not cognite_implements_concepts:
+            raise NeatValueError("None of the classes implement Cognite Core concepts.")
+        return cognite_implements_concepts
+
+    def _get_views_by_class(
+        self, classes: set[ClassEntity], default_space: str, default_version: str
+    ) -> dict[ClassEntity, View]:
+        view_ids = [class_.as_view_entity(default_space, default_version).as_id() for class_ in classes]
+        views = self._client.loaders.views.retrieve(view_ids, include_ancestor=True, include_connected=True)
+        return {ClassEntity(prefix=view.space, suffix=view.external_id, version=view.version): view for view in views}

cognite/neat/_session/_base.py

@@ -168,7 +168,7 @@ class NeatSession:
         self._state._raise_exception_if_condition_not_met(
             "Convert to physical", has_dms_rules=False, has_information_rules=True
         )
-        converter = InformationToDMS(reserved_properties=reserved_properties)
+        converter = InformationToDMS(reserved_properties=reserved_properties, client=self._state.client)
 
         issues = self._state.rule_transform(converter)
 

cognite/neat/_session/_template.py

@@ -1,16 +1,24 @@
-from typing import Literal
+from pathlib import Path
+from typing import Any, Literal
 
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
-from cognite.neat._issues import IssueList
+from cognite.neat._alpha import ExperimentalFlags
+from cognite.neat._issues import IssueList, catch_issues
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.exporters import ExcelExporter
+from cognite.neat._rules.importers import ExcelImporter
+from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
+    AddCogniteProperties,
     IncludeReferenced,
     ToDataProductModel,
     ToEnterpriseModel,
     ToSolutionModel,
     VerifiedRulesTransformer,
 )
+from cognite.neat._utils.reader import NeatReader, PathReader
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -165,3 +173,52 @@ class TemplateAPI:
         if last_rules and not issues.has_errors:
             self._state.last_reference = last_rules
         return issues
+
+    def extension(self, io: Any, output: str | Path | None = None) -> IssueList:
+        """Creates a template for an extension of a Cognite model.
+
+        The input is a spreadsheet of a conceptual model in which the concepts are defined
+        and marked with the Cognite concept they are extending. For example, if you have a pump
+        in the Classes sheet you will see
+        ```
+        Class: Pump
+        Implements: cdf_cdm:CogniteAsset(version=v1)
+        ```
+        The output will be a spreadsheet in which all the properties from the Cognite concept model
+        is added to the spreadsheet. In the example above, the pump concept will have all
+        the properties it inherits from the CogniteAsset concept added to the Properties spreadsheet.
+
+
+        Args:
+            io: The input spreadsheet.
+            output: The output spreadsheet. If None, the output will be the same
+                as the input with `_extension` added to the name.
+        """
+        ExperimentalFlags.extension.warn()
+        reader = NeatReader.create(io)
+        path = reader.materialize_path()
+        if output is None:
+            if isinstance(reader, PathReader):
+                output_path = path.with_name(f"{path.stem}_extension{path.suffix}")
+            else:
+                # The source is not a file, for example, a URL or a stream.
+                output_path = Path.cwd() / f"{path.stem}_extension{path.suffix}"
+        else:
+            output_path = Path(output)
+
+        with catch_issues() as issues:
+            read: ReadRules[InformationInputRules] = ExcelImporter(path).to_rules()
+            if read.rules is not None:
+                # If rules are None there will be issues that are already caught.
+                if not isinstance(read.rules, InformationInputRules):
+                    raise NeatSessionError(f"The input {reader.name} must contain an InformationInputRules object. ")
+                if self._state.client is None:
+                    raise NeatSessionError("Client must be set in the session to run the extension.")
+                modified = AddCogniteProperties(self._state.client).transform(read)
+                if modified.rules is not None:
+                    # If rules are None there will be issues that are already caught.
+                    info = modified.rules.as_verified_rules()
+
+                    ExcelExporter(styling="maximal").export_to_file(info, output_path)
+        issues.action = "Created extension template"
+        return issues

cognite/neat/_utils/text.py

@@ -192,7 +192,29 @@ def replace_non_alphanumeric_with_underscore(text: str) -> str:
     return re.sub(r"\W+", "_", text)
 
 
-def humanize_collection(collection: Collection[Any], /, *, sort: bool = True) -> str:
+def humanize_collection(collection: Collection[Any], /, *, sort: bool = True, bind_word: str = "and") -> str:
+    """Convert a collection of items to a human-readable string.
+
+    Args:
+        collection: The collection of items to convert.
+        sort: Whether to sort the collection before converting. Default is True.
+        bind_word: The word to use to bind the last two items. Default is "and".
+
+    Returns:
+        A human-readable string of the collection.
+
+    Examples:
+        >>> humanize_collection(["b", "c", "a"])
+        'a, b and c'
+        >>> humanize_collection(["b", "c", "a"], sort=False)
+        'b, c and a'
+        >>> humanize_collection(["a", "b"])
+        'a and b'
+        >>> humanize_collection(["a"])
+        'a'
+        >>> humanize_collection([])
+
+    """
     if not collection:
         return ""
     elif len(collection) == 1:
@@ -204,7 +226,7 @@ def humanize_collection(collection: Collection[Any], /, *, sort: bool = True) ->
     else:
         sequence = list(strings)
 
-    return f"{', '.join(sequence[:-1])} and {sequence[-1]}"
+    return f"{', '.join(sequence[:-1])} {bind_word} {sequence[-1]}"
 
 
 class NamingStandardization:

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.117.12"
+__version__ = "0.119.0"
 __engine__ = "^2.0.4"

{cognite_neat-0.117.12.dist-info → cognite_neat-0.119.0.dist-info}/METADATA

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

{cognite_neat-0.117.12.dist-info → cognite_neat-0.119.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=AXLMIF5t8RmjOpSaIlfqT8ltbPc__Tb8nAVbc1pkE0Q,176
-cognite/neat/_alpha.py,sha256=AVw3YiSwpOiV3fSoTbwTxd-p7WGlS-zgf4TPZCT_9vE,1163
+cognite/neat/_alpha.py,sha256=LvvLIpOO5OBC-fIXkhe-ghEF1uSeEYoWvwT6-ajrhQw,1219
 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=LsB8k2erMZ3BJ_wLMIBhav7ykimLkV2QJjnbeC2xikE,39790
@@ -77,7 +77,7 @@ cognite/neat/_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 cognite/neat/_rules/_constants.py,sha256=XRcbXDyVlm9WkcMyJJUi8SfpLDWZTqERU7RMgZo3TSk,5922
 cognite/neat/_rules/_shared.py,sha256=6pl0qCp-2xn5CW6i6opD_6mVuXzblLpoc5323UNVvmY,1356
 cognite/neat/_rules/analysis/__init__.py,sha256=0Y7KiXpzrwOIU7GVlC3zlizj1TXe6sodAJzMh1rTZLE,62
-cognite/neat/_rules/analysis/_base.py,sha256=t9NBxZoM95_7UqOa9coWzsH0Kv6neKcb0dtebTV2KnI,23434
+cognite/neat/_rules/analysis/_base.py,sha256=D6jjMlgwMpXsgwF1WSWtiU6QTJfocHlkHdmSUtf_IWE,23555
 cognite/neat/_rules/catalog/__init__.py,sha256=dwDB8b-5GKZuwVyPuiwsH0EaK2FY9-wJrkTjKoL8KE4,250
 cognite/neat/_rules/catalog/classic_model.xlsx,sha256=YkocpkKypizjsWYwOdn5yzIz_BSl8T8SQLxgm4GIjLQ,15014
 cognite/neat/_rules/catalog/hello_world_pump.xlsx,sha256=E63t5U1PQLIoUfXp1mEuhuq8I2TGKovZlEfIhO5bevw,23322
@@ -92,7 +92,7 @@ cognite/neat/_rules/exporters/_rules2yaml.py,sha256=ggaPR8FO8PwZk1_nhwb5wVHk_C4s
 cognite/neat/_rules/exporters/_validation.py,sha256=DVJGdNNU2WtAFgUg0h4SWVhveRErEPOcYdT65y5toV0,682
 cognite/neat/_rules/importers/__init__.py,sha256=KiTNglSK6OVCdvPiGmO2dTKEGQJWT5Yxa6XWqm7YClQ,1408
 cognite/neat/_rules/importers/_base.py,sha256=yLrrOgjtkSPfLACmtRXGlHmaeGkk0kGnowregWbIPUo,1940
-cognite/neat/_rules/importers/_dms2rules.py,sha256=DzlNZHjGLGvXylTxVBkGt4sKOuIPS5_WhTnYGh9Eldc,23393
+cognite/neat/_rules/importers/_dms2rules.py,sha256=RyqRT7O-iEIxMeuDlVt2DcA8FQFm3Op2YvAWMTKLJjo,27524
 cognite/neat/_rules/importers/_dtdl2rules/__init__.py,sha256=CNR-sUihs2mnR1bPMKs3j3L4ds3vFTsrl6YycExZTfU,68
 cognite/neat/_rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17guY0dc4OseJDQfqHy_QZBtm0OD6g,12134
 cognite/neat/_rules/importers/_dtdl2rules/dtdl_converter.py,sha256=jZJEMD_RDhKK4berSfNKypfhASTMhXW3GYXHyanWTPc,11715
@@ -125,18 +125,18 @@ cognite/neat/_rules/models/entities/_types.py,sha256=df9rnXJJKciv2Bp-Ve2q4xdEJt6
 cognite/neat/_rules/models/entities/_wrapped.py,sha256=L8ujfOHLQxkUzuJWHgdpPUCaHbjcCdDUiKsyApS7McU,7756
 cognite/neat/_rules/models/information/__init__.py,sha256=lV7l8RTfWBvN_DFkzea8OzADjq0rZGgWe_0Fiwtfje0,556
 cognite/neat/_rules/models/information/_rules.py,sha256=eb1_uunWmEnZV0rnuGq7-GyDICJU5yvGrzQNHSGoUKE,13561
-cognite/neat/_rules/models/information/_rules_input.py,sha256=Pk6DNwDfTUr5DbbuIaFj0ICS9XmwqbhYlaz1d96ouDk,6037
+cognite/neat/_rules/models/information/_rules_input.py,sha256=zNw8zAuidGqGxnI9Ze_KrEur94dq9d0X-NhIS5ox7r4,6244
 cognite/neat/_rules/models/information/_validation.py,sha256=8o1rQ8lGY5yXP-ZiDX64opx7mHZGofHSxr-6972xEmI,12170
 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=ei-nuivNWVW9HmvzDBKIPF6ZdgaMq64XHw_rKm0CMxg,22584
-cognite/neat/_rules/transformers/__init__.py,sha256=vp6OQnRUGdIrPVDOsY_tM2KBzis-IldaoVkAQEFgvVM,1563
+cognite/neat/_rules/transformers/__init__.py,sha256=icjtZq6Hc122fEj9AGEcDB8QuF2JL6dWe4utne73naQ,1617
 cognite/neat/_rules/transformers/_base.py,sha256=9LnjKbYIf9238PQXedkTZsMXAyEND6glUD187iEaHfc,2783
-cognite/neat/_rules/transformers/_converters.py,sha256=cCMvSrk6LPMyA3k9-4j0qCNi9FdsWRhSifKnr8j4UmQ,89385
+cognite/neat/_rules/transformers/_converters.py,sha256=pel46GyIBVKeYb_GoflHc0uq5pVPayc2ePrIBwNb0fk,104666
 cognite/neat/_rules/transformers/_mapping.py,sha256=QVd96vMF9sGailN5hB22KGdmOU8GzFwZ7IPMD0aVCYY,18237
 cognite/neat/_rules/transformers/_verification.py,sha256=coZjoLqdfS8yrPP62T_xEKrDZc9ETbPWrLuwEVBSLZQ,4370
 cognite/neat/_session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/_session/_base.py,sha256=7NRswQdQOdB-2Cb-WavzzKZDyEOpJBCcO18KTCGu9Tw,12317
+cognite/neat/_session/_base.py,sha256=WrX4g-pf4GnnYpusSoNkmKyjH_IfB9ZWfXw34THMqy0,12344
 cognite/neat/_session/_collector.py,sha256=ipYlwBBgjF53adjDW_D1U39mLEviB3UOVSGgeqHkEuc,4228
 cognite/neat/_session/_drop.py,sha256=gOkDAnddASpFxYxkPjlTyhkpNfnmDEj94GRI8tnHFR0,4167
 cognite/neat/_session/_explore.py,sha256=hrL0ASLtEXLlZn0dgDsKNySO10qEMBT8cE8mti2lOws,1561
@@ -149,7 +149,7 @@ cognite/neat/_session/_set.py,sha256=dCZ5zEmNAw8tiqOGT7-EigSXOIGlfVP2ldA7nmC8LJ8
 cognite/neat/_session/_show.py,sha256=2lnkud996ouwf6-aKGvU0cU0ttfMeQ3vcb__g_7Yko4,10539
 cognite/neat/_session/_state.py,sha256=6b0BSXm7m5-OcsF_O0A_7ec9tt8oPqH8zHImyEhVQQA,6313
 cognite/neat/_session/_subset.py,sha256=4RFGC8apNLnRSKcoDh95ksXA7zLy8vGLxEV5U0H3Hoc,2687
-cognite/neat/_session/_template.py,sha256=A0mx65fs-07eJcRk46LklRBmTUtO181EvOwsz74G4go,7538
+cognite/neat/_session/_template.py,sha256=oR11KXyEGUGKjKthsehK7-3xI2n3_3ZAsRQ66wHXs8o,10458
 cognite/neat/_session/_to.py,sha256=S7209afgOlLWbsKOA0Z4lAwT57gzLmSDaUWpUaWjJJY,19118
 cognite/neat/_session/_wizard.py,sha256=9idlzhZy54h2Iwupe9iXKX3RDb5jJQuBZFEouni50L0,1476
 cognite/neat/_session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvca6n48bu_bI,120
@@ -173,14 +173,14 @@ cognite/neat/_utils/rdf_.py,sha256=eCN1HBuL4NvPwE2WTnkz-6evnECQ8PveLqYAcpBfA9E,9
 cognite/neat/_utils/reader/__init__.py,sha256=fPkrNB_9hLB7CyHTCFV_xEbIfOMqUQzNly5JN33-QfM,146
 cognite/neat/_utils/reader/_base.py,sha256=PpD7OKVPTMHF6mqBY7L3XcUw3nv-drEbOzBoSSildlM,5412
 cognite/neat/_utils/spreadsheet.py,sha256=Jo1ib9RgbHkAoekO5Yu1-_nF_O6pXhsyBGNgInQwkts,5378
-cognite/neat/_utils/text.py,sha256=qy7lgMdRjzxSYkL8teAnWsq6T5baS_QcezHLK007_7M,7791
+cognite/neat/_utils/text.py,sha256=9T0mzcNn6J9X8DriNntLN5ThCXOWbU1BYareukbLT7A,8507
 cognite/neat/_utils/time_.py,sha256=7ayUm0OWZm1JDmy32E4ip8WRr2o0GLwrHwJA8sJ43Z4,357
 cognite/neat/_utils/upload.py,sha256=xWtM6mFuD2QYQHaZ7zCAuGptbEpPIxcH-raWQu93-Ug,5845
 cognite/neat/_utils/xml_.py,sha256=FQkq84u35MUsnKcL6nTMJ9ajtG9D5i1u4VBnhGqP2DQ,1710
-cognite/neat/_version.py,sha256=UiPaIrCQ2Dtlfchy7Yn9lrRzE0x1d8c6iWHSSVJ1chY,47
+cognite/neat/_version.py,sha256=TJTHDgA0OrwVmqyL7--NeoKjn6AUK1SpOFTw5WFlYms,46
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-0.117.12.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.117.12.dist-info/METADATA,sha256=CrA6mTX8srnTM6XDzWoLx632BTbkkucd4lIpQ2IvNWg,5422
-cognite_neat-0.117.12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-cognite_neat-0.117.12.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
-cognite_neat-0.117.12.dist-info/RECORD,,
+cognite_neat-0.119.0.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.119.0.dist-info/METADATA,sha256=83ednd4awU-v4LrLtW-WNmIV9LE0HAe0C_hkKQup5wo,5421
+cognite_neat-0.119.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+cognite_neat-0.119.0.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
+cognite_neat-0.119.0.dist-info/RECORD,,