cognite-neat 0.123.14__py3-none-any.whl → 0.123.16__py3-none-any.whl

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.14"
+__version__ = "0.123.16"
 __engine__ = "^2.0.4"

cognite/neat/core/_data_model/exporters/_data_model2excel.py

@@ -344,7 +344,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
         for value_type_counter, value_type in enumerate(_DATA_TYPE_BY_DMS_TYPE.values()):
             value_type_as_str = value_type.dms._type.casefold() if role == RoleTypes.dms else value_type.xsd
             # skip types which require special handling or are surpassed by CDM
-            if value_type_as_str in ["enum", "timeseries", "sequence", "file", "json"]:
+            if value_type_as_str in ["enum", "timeseries", "sequence", "file"]:
                 continue
             workbook[self._helper_sheet_name].cell(
                 row=value_type_counter + 1,

cognite/neat/core/_data_model/models/conceptual/_validation.py

@@ -2,6 +2,7 @@ import itertools
 from collections import Counter, defaultdict
 from collections.abc import Iterable
 
+from cognite.neat.core._constants import get_base_concepts
 from cognite.neat.core._data_model._constants import PATTERNS, EntityTypes
 from cognite.neat.core._data_model.models.entities import ConceptEntity, UnknownEntity
 from cognite.neat.core._data_model.models.entities._multi_value import MultiValueTypeInfo
@@ -35,23 +36,31 @@ class ConceptualValidation:
         data_model: ConceptualDataModel,
         read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
     ):
+        # import here to avoid circular import issues
+        from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
+
         self.data_model = data_model
+        self.analysis = DataModelAnalysis(self.data_model)
         self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
         self._metadata = data_model.metadata
         self._properties = data_model.properties
         self._concepts = data_model.concepts
+        self._cdf_concepts = {
+            ConceptEntity.load(concept_as_string) for concept_as_string in get_base_concepts(base_model="CogniteCore")
+        }
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
         self._duplicated_resources()
         self._namespaces_reassigned()
-        self._classes_without_properties()
-        self._undefined_classes()
-        self._parent_concept_defined()
-        self._referenced_classes_exist()
-        self._referenced_value_types_exist()
-        self._concept_only_data_model()
+        self._concepts_without_properties_exist()
+        self._concepts_with_properties_defined()
+        self._ancestors_defined()
+
+        self._object_properties_use_defined_concepts()
         self._dangling_properties()
+
+        self._concept_only_data_model()
         self._regex_compliance_with_physical_data_model()
 
         return self.issue_list
@@ -59,23 +68,23 @@ class ConceptualValidation:
     def _concept_only_data_model(self) -> None:
         """Check if the data model only consists of concepts without any properties."""
         if not self._properties:
-            self.issue_list.append(ConceptOnlyDataModelWarning())
+            self.issue_list.append_if_not_exist(ConceptOnlyDataModelWarning())
 
     def _dangling_properties(self) -> None:
         """Check if there are properties that do not reference any concept."""
         dangling_properties = [prop for prop in self._properties if prop.concept == UnknownEntity()]
         if dangling_properties:
             for prop in dangling_properties:
-                self.issue_list.append(DanglingPropertyWarning(property_id=prop.property_))
+                self.issue_list.append_if_not_exist(DanglingPropertyWarning(property_id=prop.property_))
 
     def _duplicated_resources(self) -> None:
-        properties_sheet = self._read_info_by_spreadsheet.get("Properties")
-        concepts_sheet = self._read_info_by_spreadsheet.get("Concepts")
+        properties_sheet_info = self._read_info_by_spreadsheet.get("Properties")
+        concepts_sheet_info = self._read_info_by_spreadsheet.get("Concepts")
 
         visited = defaultdict(list)
         for row_no, property_ in enumerate(self._properties):
             visited[property_._identifier()].append(
-                properties_sheet.adjusted_row_number(row_no) if properties_sheet else row_no + 1
+                properties_sheet_info.adjusted_row_number(row_no) if properties_sheet_info else row_no + 1
             )
 
         for identifier, rows in visited.items():
@@ -96,46 +105,47 @@ class ConceptualValidation:
         visited = defaultdict(list)
         for row_no, concept in enumerate(self._concepts):
             visited[concept._identifier()].append(
-                concepts_sheet.adjusted_row_number(row_no) if concepts_sheet else row_no + 1
+                concepts_sheet_info.adjusted_row_number(row_no) if concepts_sheet_info else row_no + 1
             )
 
         for identifier, rows in visited.items():
             if len(rows) == 1:
                 continue
-            self.issue_list.append(
+            self.issue_list.append_if_not_exist(
                 ResourceDuplicatedError(
                     identifier[0],
                     "concept",
-                    (f"the Classes sheet at row {humanize_collection(rows)} if data model is read from a spreadsheet."),
+                    (
+                        f"the Concepts sheet at row {humanize_collection(rows)}"
+                        " if data model is read from a spreadsheet."
+                    ),
                 )
             )
 
-    def _classes_without_properties(self) -> None:
-        defined_concepts = {concept.concept for concept in self._concepts}
-        referred_classes = {property_.concept for property_ in self._properties}
-        concept_parent_pairs = self._concept_parent_pairs()
-
-        if concepts_without_properties := defined_concepts.difference(referred_classes):
-            for concept in concepts_without_properties:
-                # USE CASE: class has no direct properties and no parents with properties
-                # and it is a class in the prefix of data model, as long as it is in the
-                # same prefix, meaning same space
-                if not concept_parent_pairs[concept] and concept.prefix == self._metadata.prefix:
-                    self.issue_list.append(
-                        ResourceNotDefinedWarning(
-                            resource_type="concept",
-                            identifier=concept,
-                            location="Properties sheet",
-                        )
-                    )
-
-    def _undefined_classes(self) -> None:
-        defined_concept = {concept.concept for concept in self._concepts}
-        referred_concepts = {property_.concept for property_ in self._properties} - {UnknownEntity()}
-
-        if undefined_concepts := referred_concepts.difference(defined_concept):
-            for concept in undefined_concepts:
-                self.issue_list.append(
+    def _concepts_without_properties_exist(self) -> None:
+        """This validation checks if concepts have properties defined or inherit properties from other concepts."""
+        concepts = {concept.concept for concept in self._concepts}
+        ancestors_by_concept = self.analysis.parents_by_concept(include_ancestors=True, include_different_space=True)
+        concepts_with_properties = self.analysis.defined_concepts().union(self._cdf_concepts)
+
+        if candidate_concepts := concepts.difference(concepts_with_properties):
+            for concept in candidate_concepts:
+                # Here we check if at least one of the ancestors of the concept has properties
+                if (ancestors := ancestors_by_concept.get(concept)) and ancestors.intersection(
+                    concepts_with_properties
+                ):
+                    continue
+
+                self.issue_list.append_if_not_exist(UndefinedConceptWarning(concept_id=str(concept)))
+
+    def _concepts_with_properties_defined(self) -> None:
+        """This validation checks if concepts to which properties are attached are defined."""
+        concepts = {concept.concept for concept in self._concepts}
+        concepts_with_properties = {property_.concept for property_ in self._properties} - {UnknownEntity()}
+
+        if undefined_concepts_with_properties := concepts_with_properties.difference(concepts):
+            for concept in undefined_concepts_with_properties:
+                self.issue_list.append_if_not_exist(
                     ResourceNotDefinedError(
                         identifier=concept,
                         resource_type="concept",
@@ -143,57 +153,44 @@ class ConceptualValidation:
                     )
                 )
 
-    def _parent_concept_defined(self) -> None:
-        """This is a validation to check if the parent concept is defined."""
-        concept_parent_pairs = self._concept_parent_pairs()
-        concepts = set(concept_parent_pairs.keys())
-        parents = set(itertools.chain.from_iterable(concept_parent_pairs.values()))
-
-        if undefined_parents := parents.difference(concepts):
-            for parent in undefined_parents:
-                if parent.prefix != self._metadata.prefix:
-                    self.issue_list.append(UndefinedConceptWarning(concept_id=str(parent)))
-                else:
-                    self.issue_list.append(
-                        ResourceNotDefinedWarning(
-                            resource_type="concept",
-                            identifier=parent,
-                            location="Concepts sheet",
-                        )
-                    )
-
-    def _referenced_classes_exist(self) -> None:
-        # needs to be complete for this validation to pass
-        defined_concept = {concept.concept for concept in self._concepts}
-        classes_with_explicit_properties = {property_.concept for property_ in self._properties} - {UnknownEntity()}
+    def _ancestors_defined(self) -> None:
+        """This is a validation to check if the ancestor concepts (e.g. parents) are defined."""
+        concepts = {concept.concept for concept in self._concepts}.union(self._cdf_concepts)
+        ancestors = set(
+            itertools.chain.from_iterable(
+                self.analysis.parents_by_concept(include_ancestors=True, include_different_space=True).values()
+            )
+        ).difference(self._cdf_concepts)
 
-        # USE CASE: models are complete
-        if missing_classes := classes_with_explicit_properties.difference(defined_concept):
-            for concept in missing_classes:
-                self.issue_list.append(
+        if undefined_ancestor := ancestors.difference(concepts):
+            for ancestor in undefined_ancestor:
+                self.issue_list.append_if_not_exist(
                     ResourceNotDefinedWarning(
                         resource_type="concept",
-                        identifier=concept,
+                        identifier=ancestor,
                         location="Concepts sheet",
                     )
                 )
 
-    def _referenced_value_types_exist(self) -> None:
-        # adding UnknownEntity to the set of defined classes to handle the case where a property references an unknown
-        defined_classes = {concept.concept for concept in self._concepts} | {UnknownEntity()}
-        referred_object_types = {
+    def _object_properties_use_defined_concepts(self) -> None:
+        """Check if the value types of object properties are defined as concepts."""
+
+        concepts = {concept.concept for concept in self._concepts}
+
+        # We remove UnknownEntity from the concepts to avoid false positives
+        # as `UnknownEntity` is used as a placeholder when the value type is not defined.
+        value_types = {
             property_.value_type
             for property_ in self.data_model.properties
             if property_.type_ == EntityTypes.object_property
-        }
+        }.difference({UnknownEntity()})
 
-        if missing_value_types := referred_object_types.difference(defined_classes):
-            # Todo: include row and column number
-            for missing in missing_value_types:
-                self.issue_list.append(
+        if undefined_value_types := value_types.difference(concepts):
+            for value_type in undefined_value_types:
+                self.issue_list.append_if_not_exist(
                     ResourceNotDefinedWarning(
                         resource_type="concept",
-                        identifier=missing,
+                        identifier=value_type,
                         location="Concepts sheet",
                     )
                 )
@@ -203,7 +200,7 @@ class ConceptualValidation:
 
         for prop_ in self._properties:
             if not PATTERNS.physical_property_id_compliance.match(prop_.property_):
-                self.issue_list.append(
+                self.issue_list.append_if_not_exist(
                     ResourceRegexViolationWarning(
                         prop_.property_,
                         "Property",
@@ -212,7 +209,7 @@ class ConceptualValidation:
                     )
                 )
             if prop_.concept != UnknownEntity() and not PATTERNS.view_id_compliance.match(prop_.concept.suffix):
-                self.issue_list.append(
+                self.issue_list.append_if_not_exist(
                     ResourceRegexViolationWarning(
                         prop_.concept,
                         "Concept",
@@ -227,7 +224,7 @@ class ConceptualValidation:
                 and prop_.value_type != UnknownEntity()
                 and not PATTERNS.view_id_compliance.match(prop_.value_type.suffix)
             ):
-                self.issue_list.append(
+                self.issue_list.append_if_not_exist(
                     ResourceRegexViolationWarning(
                         prop_.value_type,
                         "Value Type",
@@ -242,7 +239,7 @@ class ConceptualValidation:
                         and prop_.value_type != UnknownEntity()
                         and not PATTERNS.view_id_compliance.match(value_type.suffix)
                     ):
-                        self.issue_list.append(
+                        self.issue_list.append_if_not_exist(
                             ResourceRegexViolationWarning(
                                 value_type,
                                 "Value Type",
@@ -253,7 +250,7 @@ class ConceptualValidation:
 
         for concepts in self._concepts:
             if not PATTERNS.view_id_compliance.match(concepts.concept.suffix):
-                self.issue_list.append(
+                self.issue_list.append_if_not_exist(
                     ResourceRegexViolationWarning(
                         concepts.concept,
                         "Concept",
@@ -265,7 +262,7 @@ class ConceptualValidation:
             if concepts.implements:
                 for parent in concepts.implements:
                     if not PATTERNS.view_id_compliance.match(parent.suffix):
-                        self.issue_list.append(
+                        self.issue_list.append_if_not_exist(
                             ResourceRegexViolationWarning(
                                 parent,
                                 "Concept",
@@ -274,18 +271,6 @@ class ConceptualValidation:
                             )
                         )
 
-    def _concept_parent_pairs(self) -> dict[ConceptEntity, list[ConceptEntity]]:
-        concept_parent_pairs: dict[ConceptEntity, list[ConceptEntity]] = {}
-        concepts = self.data_model.model_copy(deep=True).concepts
-
-        for concept in concepts:
-            concept_parent_pairs[concept.concept] = []
-            if concept.implements is None:
-                continue
-            concept_parent_pairs[concept.concept].extend(concept.implements)
-
-        return concept_parent_pairs
-
     def _namespaces_reassigned(self) -> None:
         prefixes = self.data_model.prefixes.copy()
         prefixes[self.data_model.metadata.namespace.prefix] = self.data_model.metadata.namespace
@@ -293,7 +278,7 @@ class ConceptualValidation:
         if len(set(prefixes.values())) != len(prefixes):
             reused_namespaces = [value for value, count in Counter(prefixes.values()).items() if count > 1]
             impacted_prefixes = [key for key, value in prefixes.items() if value in reused_namespaces]
-            self.issue_list.append(
+            self.issue_list.append_if_not_exist(
                 NeatValueError(
                     "Namespace collision detected. The following prefixes "
                     f"are assigned to the same namespace: {impacted_prefixes}"

cognite/neat/core/_data_model/transformers/__init__.py

@@ -26,6 +26,7 @@ from ._converters import (
     ToSolutionModel,
 )
 from ._mapping import AsParentPropertyId, MapOneToOne, PhysicalDataModelMapper
+from ._union_conceptual import UnionConceptualDataModel
 from ._verification import (
     VerifyAnyDataModel,
     VerifyConceptualDataModel,
@@ -61,6 +62,7 @@ __all__ = [
     "ToEnterpriseModel",
     "ToExtensionModel",
     "ToSolutionModel",
+    "UnionConceptualDataModel",
     "VerifiedDataModelTransformer",
     "VerifyAnyDataModel",
     "VerifyConceptualDataModel",

cognite/neat/core/_data_model/transformers/_union_conceptual.py

@@ -0,0 +1,208 @@
+from collections.abc import Iterable, Set
+from typing import Literal
+
+from cognite.neat.core._data_model.models import ConceptualDataModel, SheetList
+from cognite.neat.core._data_model.models.conceptual import Concept, ConceptualProperty
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import (
+    ConceptEntity,
+    MultiValueTypeInfo,
+    UnknownEntity,
+)
+from cognite.neat.core._data_model.transformers import VerifiedDataModelTransformer
+
+
+class UnionConceptualDataModel(VerifiedDataModelTransformer[ConceptualDataModel, ConceptualDataModel]):
+    """Takes the union two conceptual models.
+    Args:
+        primary: The primary model to merge with the secondary model given in the transform method.
+    """
+
+    def __init__(self, primary: ConceptualDataModel) -> None:
+        self.primary = primary
+
+    def transform(self, data_model: ConceptualDataModel) -> ConceptualDataModel:
+        primary_model = self.primary
+        secondary_model = data_model
+
+        output = primary_model.model_copy(deep=True)
+        secondary_concepts = {cls.concept: cls for cls in secondary_model.concepts}
+        secondary_properties = {(prop.concept, prop.property_): prop for prop in secondary_model.properties}
+
+        union_concepts_by_id = self._union_concepts(output.concepts, secondary_concepts)
+        output.concepts = SheetList[Concept](union_concepts_by_id.values())
+
+        union_properties = self._union_properties(
+            output.properties, secondary_properties, set(union_concepts_by_id.keys())
+        )
+        output.properties = SheetList[ConceptualProperty](union_properties.values())
+
+        return output
+
+    def _union_concepts(
+        self, primary_concepts: Iterable[Concept], new_concepts: dict[ConceptEntity, Concept]
+    ) -> dict[ConceptEntity, Concept]:
+        union_concepts = {cls.concept: cls for cls in primary_concepts}
+        for concept, primary_concept in union_concepts.items():
+            if concept not in new_concepts:
+                continue
+            secondary_concept = new_concepts[concept]
+            union_concepts[concept] = self.union_concepts(
+                primary=primary_concept,
+                secondary=secondary_concept,
+                conflict_resolution="combined",
+            )
+
+        for concept, secondary_concept in new_concepts.items():
+            if concept not in union_concepts:
+                union_concepts[concept] = secondary_concept
+        return union_concepts
+
+    def _union_properties(
+        self,
+        primary_properties: Iterable[ConceptualProperty],
+        secondary_properties: dict[tuple[ConceptEntity, str], ConceptualProperty],
+        used_concepts: Set[ConceptEntity],
+    ) -> dict[tuple[ConceptEntity, str], ConceptualProperty]:
+        union_properties = {(prop.concept, prop.property_): prop for prop in primary_properties}
+        for (concept, prop_id), primary_property in union_properties.items():
+            if (concept not in used_concepts) or (concept, prop_id) not in secondary_properties:
+                continue
+            secondary_property = secondary_properties[(concept, prop_id)]
+            union_properties[(concept, prop_id)] = self.union_properties(
+                primary=primary_property,
+                secondary=secondary_property,
+                conflict_resolution="combined",
+            )
+
+        for (concept, prop_id), prop in secondary_properties.items():
+            if (concept, prop_id) not in union_properties and concept in used_concepts:
+                union_properties[(concept, prop_id)] = prop
+        return union_properties
+
+    @classmethod
+    def union_concepts(
+        cls,
+        primary: Concept,
+        secondary: Concept,
+        conflict_resolution: Literal["priority", "combined"] = "priority",
+    ) -> Concept:
+        """Union two concepts.
+
+        Args:
+            primary (Concept): The primary concept.
+            secondary (Concept): The secondary concept.
+            conflict_resolution (Literal["priority", "combined"]): How to resolve conflicts:
+                - "priority": Keep the primary concept with fallback to the secondary.
+                - "combined": Merge implements from both concepts. (only applies to implements)
+        Returns:
+            Concept: The union of the two concepts.
+
+        """
+        if conflict_resolution == "combined":
+            all_implements = (primary.implements or []) + (secondary.implements or [])
+            implements = list(dict.fromkeys(all_implements))
+        else:
+            implements = (primary.implements or secondary.implements or []).copy()
+
+        return Concept(
+            neatId=primary.neatId,
+            concept=primary.concept,
+            name=primary.name or secondary.name,
+            description=primary.description or secondary.description,
+            implements=implements,
+            instance_source=primary.instance_source or secondary.instance_source,
+            physical=primary.physical,
+        )
+
+    @classmethod
+    def union_properties(
+        cls,
+        primary: ConceptualProperty,
+        secondary: ConceptualProperty,
+        conflict_resolution: Literal["priority", "combined"] = "priority",
+    ) -> ConceptualProperty:
+        """Union two conceptual properties.
+
+        Args:
+            primary (ConceptualProperty): The primary property.
+            secondary (ConceptualProperty): The secondary property.
+            conflict_resolution (Literal["priority", "combined"]): How to resolve conflicts:
+                - "priority": Keep the primary property with fallback to the secondary.
+                - "combined": Merge value types and instance sources.
+        Returns:
+            ConceptualProperty: The union of the two properties.
+
+        """
+        if conflict_resolution == "combined":
+            all_sources = (primary.instance_source or []) + (secondary.instance_source or [])
+            instance_source = list(dict.fromkeys(all_sources))
+        else:
+            instance_source = (primary.instance_source or secondary.instance_source or []).copy()
+
+        use_primary = conflict_resolution == "priority"
+        return ConceptualProperty(
+            neatId=primary.neatId,
+            concept=primary.concept,
+            property_=primary.property_,
+            name=primary.name or secondary.name,
+            description=primary.description or secondary.description,
+            min_count=primary.min_count
+            if use_primary
+            else cls._union_min_count(primary.min_count, secondary.min_count),
+            max_count=primary.max_count
+            if use_primary
+            else cls._union_max_count(primary.max_count, secondary.max_count),
+            default=primary.default or secondary.default,
+            value_type=primary.value_type
+            if use_primary
+            else cls.union_value_type(primary.value_type, secondary.value_type),
+            instance_source=instance_source,
+            inherited=primary.inherited,
+            physical=primary.physical,
+        )
+
+    @staticmethod
+    def _union_min_count(primary: int | None, secondary: int | None) -> int | None:
+        if primary is None:
+            return secondary
+        if secondary is None:
+            return primary
+        return min(primary, secondary)
+
+    @staticmethod
+    def _union_max_count(primary: int | float | None, secondary: int | float | None) -> int | float | None:
+        if primary is None:
+            return secondary
+        if secondary is None:
+            return primary
+        output = max(primary, secondary)
+        try:
+            return int(output)
+        except (OverflowError, ValueError):
+            # The value is float('inf') or float('-inf')
+            return output
+
+    @staticmethod
+    def union_value_type(
+        primary: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity,
+        secondary: DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity,
+    ) -> DataType | ConceptEntity | MultiValueTypeInfo | UnknownEntity:
+        all_types: list[DataType | ConceptEntity] = []
+        for type_ in (primary, secondary):
+            if isinstance(type_, MultiValueTypeInfo):
+                all_types.extend(type_.types)
+            elif isinstance(type_, UnknownEntity):
+                continue
+            elif isinstance(type_, DataType | ConceptEntity):
+                all_types.append(type_)
+            else:
+                raise NotImplementedError(f"Unsupported type: {type_}")
+
+        ordered_types = list(dict.fromkeys(all_types))
+        if len(ordered_types) == 0:
+            return UnknownEntity()
+        if len(ordered_types) == 1:
+            return ordered_types[0]
+        else:  # len(ordered_types) > 1:
+            return MultiValueTypeInfo(types=ordered_types)

cognite/neat/core/_issues/_base.py

@@ -255,6 +255,11 @@ class IssueList(list, Sequence[NeatIssue]):
         self.action = action
         self.hint = hint
 
+    def append_if_not_exist(self, issue: NeatIssue) -> None:
+        """Append an issue to the list if it does not already exist."""
+        if issue not in self:
+            self.append(issue)
+
     @property
     def errors(self) -> Self:
         """Return all the errors in this list."""

cognite/neat/core/_issues/warnings/_models.py

@@ -94,9 +94,9 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
 
 @dataclass(unsafe_hash=True)
 class UndefinedConceptWarning(UserModelingWarning):
-    """Class {concept_id} has no explicit properties defined neither implements other concepts"""
+    """Concept {concept_id} has no explicit properties neither implements concepts that have properties."""
 
-    fix = "Define properties for concept or inherit properties by implementing another concept."
+    fix = "Define properties for concept or inherit properties by implementing concept(s) that has properties."
 
     concept_id: str
 

{cognite_neat-0.123.14.dist-info → cognite_neat-0.123.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.14
+Version: 0.123.16
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

{cognite_neat-0.123.14.dist-info → cognite_neat-0.123.16.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=qLY0w9gF4NJv-QQnU8dofXCm32MMtagvnj-drOInmzU,47
+cognite/neat/_version.py,sha256=BlmwKmiATKYRKR7O0PuP9r182NuNd4-ke2_e5KZ6arM,47
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
@@ -30,7 +30,7 @@ cognite/neat/core/_data_model/catalog/hello_world_pump.xlsx,sha256=E63t5U1PQLIoU
 cognite/neat/core/_data_model/exporters/__init__.py,sha256=6UbiK-dzVUCtYo09s8ICe36BbqPCur6OWB71Lwiu50U,1207
 cognite/neat/core/_data_model/exporters/_base.py,sha256=PHKTUiio4PmiEjWP9E9tJiOkfh_Po1JvcutwP_84-4A,2391
 cognite/neat/core/_data_model/exporters/_data_model2dms.py,sha256=gFSWvYV71LSzDVYsGlJ_mMxhLuKK0nwBvBiwRJhbvTE,19891
-cognite/neat/core/_data_model/exporters/_data_model2excel.py,sha256=mRVJzUCEWfm2XLhY4FZOVlRQQUT_WY84CteJVBT_khQ,25465
+cognite/neat/core/_data_model/exporters/_data_model2excel.py,sha256=88ReyrsRqoIRJcF7ezZGtsZ_0FBL0Wq7UsGI1uCXgJ4,25457
 cognite/neat/core/_data_model/exporters/_data_model2instance_template.py,sha256=9k8A70b1paeOHjvJRtbl6Xror1GD8AIMdo3cCx5aejE,6103
 cognite/neat/core/_data_model/exporters/_data_model2ontology.py,sha256=YrLTwPAvOOyLFHFJaNs4I82HCp1llJnkF1BRdoIQMck,23409
 cognite/neat/core/_data_model/exporters/_data_model2yaml.py,sha256=1dlb-v4sV8BArnX_6J4wpjQT7r-FinFAvoPDoMNkHYw,3284
@@ -52,7 +52,7 @@ cognite/neat/core/_data_model/models/_types.py,sha256=70E8fiLdZkVF2sDUGPuDhzXNA5
 cognite/neat/core/_data_model/models/data_types.py,sha256=uQ_u9KxCetLjxo-VtFzOXSxQuuf97Kg-9lfTTGzY6hc,10150
 cognite/neat/core/_data_model/models/conceptual/__init__.py,sha256=9A6myEV8s0-LqdXejaljqPj8S0pIpUL75rNdRDZzyR8,585
 cognite/neat/core/_data_model/models/conceptual/_unverified.py,sha256=VswgnTSjSCRzBX3z5HvintBGaWBPexxIs-7z7S4J57c,6298
-cognite/neat/core/_data_model/models/conceptual/_validation.py,sha256=LOnLNArteqc9TlyyRNqQgMAKx2oZ8s91WePR8fqLRlE,13888
+cognite/neat/core/_data_model/models/conceptual/_validation.py,sha256=AeTNwoby-lHVf_-7XBMPS7I_NuR3iyCCXv5wcALaNsE,13425
 cognite/neat/core/_data_model/models/conceptual/_verified.py,sha256=BUB4Ur4kpBoWiwTf57tjxJ2l0tDTSbY7zGrg1g0yVNQ,13716
 cognite/neat/core/_data_model/models/entities/__init__.py,sha256=UsW-_6fwd-TW0WcnShPKf40h75l1elVn80VurUwRAic,1567
 cognite/neat/core/_data_model/models/entities/_constants.py,sha256=GXRzVfArwxF3C67VCkzy0JWTZRkRJUYXBQaaecrqcWc,351
@@ -69,10 +69,11 @@ cognite/neat/core/_data_model/models/physical/_exporter.py,sha256=DPOytV-sIzpGJt
 cognite/neat/core/_data_model/models/physical/_unverified.py,sha256=VyI-JULAu6kHJygUclDPH1JYjhf_XcO58tI9BkXORC0,18430
 cognite/neat/core/_data_model/models/physical/_validation.py,sha256=icgNNmvc60lIxI91NGGL5Bs7rR9evNtEubYYMMeKBVg,39529
 cognite/neat/core/_data_model/models/physical/_verified.py,sha256=4_7XUj6-x74DhL8qe-duXhlNnq6ANmShB7UpICjbQW4,26783
-cognite/neat/core/_data_model/transformers/__init__.py,sha256=_FPmPh0kA68SXR4arKKNmtWQ8B2-wSwWQeGAWnjoJAQ,1788
+cognite/neat/core/_data_model/transformers/__init__.py,sha256=N6yRBplAkrwwxoTAre_1BE_fdSZL5jihr7xTQjW3KnM,1876
 cognite/neat/core/_data_model/transformers/_base.py,sha256=7adUBJgDkXgRq_h7l1q2VsLQo3lE7-xmzmHdcF4QHq8,3133
 cognite/neat/core/_data_model/transformers/_converters.py,sha256=OazYC7DgAXXEvxdiaPfJSe2ZNkYn2mRqWhtvtvWK59g,111575
 cognite/neat/core/_data_model/transformers/_mapping.py,sha256=GwmTRnhiUPIG37CgUSIbjT7ZpWOwdWuBZ_HAIIBiKYY,19024
+cognite/neat/core/_data_model/transformers/_union_conceptual.py,sha256=sg-VGjrK7PwZS1U18ov-8Or00uR3pFLOaPOYT1edD8Q,8852
 cognite/neat/core/_data_model/transformers/_verification.py,sha256=yyPK6irhMGjVtwKxRIElSsPLUvLLVfk1lBAGny6jN5w,5193
 cognite/neat/core/_instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_instances/_shared.py,sha256=6avH6mtjxjHI7JDLkXwICxGvZwooGBr6APs1_w1To-A,940
@@ -118,7 +119,7 @@ cognite/neat/core/_instances/transformers/_prune_graph.py,sha256=fWE73BndkEB7qfM
 cognite/neat/core/_instances/transformers/_rdfpath.py,sha256=4PIVpjlng59oTjoToS683XU0WgtKdEOf8zEhXCD94-I,3161
 cognite/neat/core/_instances/transformers/_value_type.py,sha256=-d18yefiGrx8CaVNLgJe0dF0zsMxtCQxlD2q2ZFGJ8U,15820
 cognite/neat/core/_issues/__init__.py,sha256=NQ-PN3fqp-hBPlpG2AZEND4cDn3_3UXAPfhLNtF5mtc,457
-cognite/neat/core/_issues/_base.py,sha256=Wfu0IxFEm-zaS631iMG_TgW_sLV3z0yn5x0IpFNS_hM,11808
+cognite/neat/core/_issues/_base.py,sha256=LZhTF_QOQvCxFrGUnWmF9gQnuyr7nM3MqXf_r8KG7GY,12003
 cognite/neat/core/_issues/_contextmanagers.py,sha256=5-QXVmfplt4S_k2csrQ2xuezOOuE5_FxSA9GVGVG1s4,1582
 cognite/neat/core/_issues/_factory.py,sha256=ifEzHZcvPyO0ZGJo8T8CE20F5L4yRzrrGPxl9d87oIs,2829
 cognite/neat/core/_issues/formatters.py,sha256=k2h_6wHW0ve52gXeuRoEcGwrxqqSe5sYFa_HycPiqW8,3323
@@ -131,7 +132,7 @@ cognite/neat/core/_issues/errors/_wrapper.py,sha256=clhuSwUuHy-FQXQopFIQRY8c_NZM
 cognite/neat/core/_issues/warnings/__init__.py,sha256=lzNZrguzwXyifehsCilAXa5UL94DWHIeO-slyC-EYZc,3165
 cognite/neat/core/_issues/warnings/_external.py,sha256=w-1R7ea6DXTIWqwlwMMjY0YxKDMSJ8gKAbp_nIIM1AI,1324
 cognite/neat/core/_issues/warnings/_general.py,sha256=_6dAFaMz-LIv7GsBBIBq2d-kmbuxVXKvU4jZeb7tjAo,972
-cognite/neat/core/_issues/warnings/_models.py,sha256=dE8Ha96WtZ9m_Bozx64NCMuJY2gWZleicD5tnnOqbe8,5086
+cognite/neat/core/_issues/warnings/_models.py,sha256=u9GH2i1vWet5fofB1ObDsiMxkLF7ZKj2s2a3J-oeiF4,5111
 cognite/neat/core/_issues/warnings/_properties.py,sha256=I3vqc1aL-ce_FRQNgQQy34RW7kQxcjbwhZIIVtGVmg8,3807
 cognite/neat/core/_issues/warnings/_resources.py,sha256=_iPRq0pRMmRu3LFjqZTaG3OqOzw4f8-Vc9G4Im__FHc,3578
 cognite/neat/core/_issues/warnings/user_modeling.py,sha256=Qn_S8TLw7MMYQaJcZBScJA48kz_PrTWz0NaepSR70Fk,4144
@@ -186,7 +187,7 @@ cognite/neat/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvc
 cognite/neat/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/session/engine/_load.py,sha256=g52uYakQM03VqHt_RDHtpHso1-mFFifH5M4T2ScuH8A,5198
-cognite_neat-0.123.14.dist-info/METADATA,sha256=OtegXPCjwnGT8EM8x8M1ekoHwwAhZ4NuNRKfz0uRxGM,9172
-cognite_neat-0.123.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.14.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.14.dist-info/RECORD,,
+cognite_neat-0.123.16.dist-info/METADATA,sha256=M0gosIy1EnoQHqzCfO7Wcm_YGDpNWf0inn1iFK754Yg,9172
+cognite_neat-0.123.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.16.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.16.dist-info/RECORD,,