cognite-neat 0.123.26__py3-none-any.whl → 1.0.22__py3-none-any.whl

cognite/neat/{core → _v0/core}/_data_model/models/physical/_exporter.py

@@ -13,20 +13,20 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat._v0.core._client.data_classes.data_modeling import (
     ContainerApplyDict,
     NodeApplyDict,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import (
+from cognite.neat._v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat._v0.core._constants import (
     COGNITE_SPACES,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat._v0.core._data_model.models.data_types import DataType, Double, Enum, Float, LangString, String
+from cognite.neat._v0.core._data_model.models.entities import (
     ConceptEntity,
     ContainerEntity,
     ContainerIndexEntity,
@@ -41,16 +41,16 @@ from cognite.neat.core._data_model.models.entities import (
     UnitEntity,
     ViewEntity,
 )
-from cognite.neat.core._issues.errors import (
+from cognite.neat._v0.core._issues.errors import (
     NeatTypeError,
     NeatValueError,
     ResourceNotFoundError,
 )
-from cognite.neat.core._issues.warnings import (
+from cognite.neat._v0.core._issues.warnings import (
     NotSupportedWarning,
     PropertyNotFoundWarning,
 )
-from cognite.neat.core._issues.warnings.user_modeling import (
+from cognite.neat._v0.core._issues.warnings.user_modeling import (
     EmptyContainerWarning,
     HasDataFilterOnNoPropertiesViewWarning,
 )
@@ -243,17 +243,21 @@ class _DMSExporter:
             connection = cast(EdgeEntity, prop.connection)
 
             if connection.direction == "inwards" and isinstance(prop.value_type, ViewEntity):
-                edge_type_candidates = outwards_type_by_view_value_type.get((prop.view, prop.value_type), [])
-                if len(edge_type_candidates) == 0:
-                    # Warning in validation, should not have an inwards connection without an outwards connection
-                    edge_type = cls._default_edge_type_from_view_id(prop.view.as_id(), prop_id)
-                elif len(edge_type_candidates) == 1:
-                    edge_type = edge_type_candidates[0]
+                if connection.edge_type is not None:
+                    edge_type = connection.edge_type.as_reference()
                 else:
-                    raise NeatValueError(
-                        f"Cannot infer edge type for {view_id}.{prop_id}, multiple candidates: {edge_type_candidates}."
-                        "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
-                    )
+                    edge_type_candidates = outwards_type_by_view_value_type.get((prop.view, prop.value_type), [])
+                    if len(edge_type_candidates) == 0:
+                        # Warning in validation, should not have an inwards connection without an outwards connection
+                        edge_type = cls._default_edge_type_from_view_id(prop.view.as_id(), prop_id)
+                    elif len(edge_type_candidates) == 1:
+                        edge_type = edge_type_candidates[0]
+                    else:
+                        raise NeatValueError(
+                            f"Cannot infer edge type for {view_id}.{prop_id}, multiple candidates: "
+                            f"{edge_type_candidates}. "
+                            "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
+                        )
                 view_property_id = (prop.view, prop.view_property)
                 edge_types_by_view_property_id[view_property_id] = edge_type
 
@@ -347,6 +351,8 @@ class _DMSExporter:
                             args["max_list_size"] = prop.max_count
                 if isinstance(prop.value_type, Double | Float) and isinstance(prop.value_type.unit, UnitEntity):
                     args["unit"] = prop.value_type.unit.as_reference()
+                if isinstance(prop.value_type, String | LangString) and prop.value_type.max_text_size is not None:
+                    args["max_text_size"] = prop.value_type.max_text_size
                 if isinstance(prop.value_type, Enum):
                     if prop.value_type.collection not in enum_values_by_collection:
                         raise ResourceNotFoundError(
@@ -377,7 +383,8 @@ class _DMSExporter:
             for prop in container_properties:
                 if prop.container_property is not None:
                     for constraint in prop.constraint or []:
-                        uniqueness_properties[constraint].add(prop.container_property)
+                        uniqueness_properties[cast(str, constraint.suffix)].add(prop.container_property)
+
             for constraint_name, properties in uniqueness_properties.items():
                 container.constraints = container.constraints or {}
                 container.constraints[constraint_name] = dm.UniquenessConstraint(properties=list(properties))

cognite/neat/{core → _v0/core}/_data_model/models/physical/_unverified.py

@@ -3,24 +3,25 @@ import sys
 import warnings
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Literal
+from typing import Any, Literal, overload
 
 import pandas as pd
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import (
+from cognite.neat._v0.core._constants import (
     DEFAULT_NAMESPACE,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._data_model._constants import SPLIT_ON_COMMA_PATTERN
-from cognite.neat.core._data_model.models._base_unverified import (
+from cognite.neat._v0.core._data_model._constants import SPLIT_ON_COMMA_PATTERN
+from cognite.neat._v0.core._data_model.models._base_unverified import (
     UnverifiedComponent,
     UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat._v0.core._data_model.models.data_types import DataType
+from cognite.neat._v0.core._data_model.models.entities import (
+    ContainerConstraintEntity,
     ContainerEntity,
     ContainerIndexEntity,
     DMSNodeEntity,
@@ -31,9 +32,9 @@ from cognite.neat.core._data_model.models.entities import (
     load_connection,
     load_dms_value_type,
 )
-from cognite.neat.core._data_model.models.entities._wrapped import DMSFilter
-from cognite.neat.core._issues.warnings import DeprecatedWarning
-from cognite.neat.core._utils.rdf_ import uri_display_name
+from cognite.neat._v0.core._data_model.models.entities._wrapped import DMSFilter
+from cognite.neat._v0.core._issues.warnings import DeprecatedWarning
+from cognite.neat._v0.core._utils.rdf_ import uri_display_name
 
 from ._verified import (
     _DEFAULT_VERSION,
@@ -138,7 +139,7 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
     container: str | None = None
     container_property: str | None = None
     index: str | list[str | ContainerIndexEntity] | ContainerIndexEntity | None = None
-    constraint: str | list[str] | None = None
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None = None
     neatId: str | URIRef | None = None
     conceptual: str | URIRef | None = None
 
@@ -161,19 +162,23 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["View"] = ViewEntity.load(self.view, space=default_space, version=default_version)
-        output["Value Type"] = load_dms_value_type(self.value_type, default_space, default_version)
-        output["Connection"] = load_connection(self.connection, default_space, default_version)
+        output["View"] = ViewEntity.load(
+            self.view, space=default_space, version=default_version, return_on_failure=True
+        )
+        output["Value Type"] = load_dms_value_type(
+            self.value_type, default_space, default_version, return_on_failure=True
+        )
+        output["Connection"] = load_connection(self.connection, default_space, default_version, return_on_failure=True)
         output["Container"] = (
-            ContainerEntity.load(self.container, space=default_space, version=default_version)
+            ContainerEntity.load(self.container, space=default_space, version=default_version, return_on_failure=True)
             if self.container
             else None
         )
         if isinstance(self.index, ContainerIndexEntity) or (isinstance(self.index, str) and "," not in self.index):
-            output["Index"] = [ContainerIndexEntity.load(self.index)]
+            output["Index"] = [ContainerIndexEntity.load(self.index, return_on_failure=True)]
         elif isinstance(self.index, str):
             output["Index"] = [
-                ContainerIndexEntity.load(index.strip())
+                ContainerIndexEntity.load(index.strip(), return_on_failure=True)
                 for index in SPLIT_ON_COMMA_PATTERN.split(self.index)
                 if index.strip()
             ]
@@ -185,16 +190,16 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
                 elif isinstance(index, str):
                     index_list.extend(
                         [
-                            ContainerIndexEntity.load(idx.strip())
+                            ContainerIndexEntity.load(idx.strip(), return_on_failure=True)
                             for idx in SPLIT_ON_COMMA_PATTERN.split(index)
                             if idx.strip()
                         ]
                     )
-                elif isinstance(index, str):
-                    index_list.append(ContainerIndexEntity.load(index.strip()))
                 else:
                     raise TypeError(f"Unexpected type for index: {type(index)}")
             output["Index"] = index_list
+
+            output["Constraint"] = _parse_constraints(self.constraint, default_space)
         return output
 
     def referenced_view(self, default_space: str, default_version: str) -> ViewEntity:
@@ -247,7 +252,7 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
     container: str
     name: str | None = None
     description: str | None = None
-    constraint: str | None = None
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None = None
     neatId: str | URIRef | None = None
     used_for: Literal["node", "edge", "all"] | None = None
 
@@ -257,23 +262,33 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
 
     def dump(self, default_space: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["Container"] = self.as_entity_id(default_space)
-        output["Constraint"] = (
-            [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
-            if self.constraint
-            else None
-        )
+        output["Container"] = self.as_entity_id(default_space, return_on_failure=True)
+        output["Constraint"] = _parse_constraints(self.constraint, default_space)
         return output
 
-    def as_entity_id(self, default_space: str) -> ContainerEntity:
-        return ContainerEntity.load(self.container, strict=True, space=default_space)
+    @overload
+    def as_entity_id(self, default_space: str, return_on_failure: Literal[False] = False) -> ContainerEntity: ...
+
+    @overload
+    def as_entity_id(self, default_space: str, return_on_failure: Literal[True]) -> ContainerEntity | str: ...
+
+    def as_entity_id(
+        self, default_space: str, return_on_failure: Literal[True, False] = False
+    ) -> ContainerEntity | str:
+        return ContainerEntity.load(
+            self.container, strict=True, space=default_space, return_on_failure=return_on_failure
+        )
 
     @classmethod
     def from_container(cls, container: dm.ContainerApply) -> "UnverifiedPhysicalContainer":
         constraints: list[str] = []
-        for _, constraint_obj in (container.constraints or {}).items():
+        for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):
-                constraints.append(str(ContainerEntity.from_id(constraint_obj.require)))
+                constraint = ContainerConstraintEntity(
+                    prefix="requires", suffix=constraint_name, require=ContainerEntity.from_id(constraint_obj.require)
+                )
+                constraints.append(str(constraint))
+
             # UniquenessConstraint it handled in the properties
         container_entity = ContainerEntity.from_id(container.as_id())
         return cls(
@@ -306,19 +321,51 @@ class UnverifiedPhysicalView(UnverifiedComponent[PhysicalView]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["View"] = self.as_entity_id(default_space, default_version)
-        output["Implements"] = self._load_implements(default_space, default_version)
+        output["View"] = self.as_entity_id(default_space, default_version, return_on_failure=True)
+        output["Implements"] = self._load_implements(default_space, default_version, return_on_failure=True)
         return output
 
-    def as_entity_id(self, default_space: str, default_version: str) -> ViewEntity:
-        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+    @overload
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[False] = False
+    ) -> ViewEntity: ...
+
+    @overload
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True]
+    ) -> ViewEntity | str: ...
+
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True, False] = False
+    ) -> ViewEntity | str:
+        return ViewEntity.load(
+            self.view, strict=True, space=default_space, version=default_version, return_on_failure=return_on_failure
+        )
+
+    @overload
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[False] = False
+    ) -> list[ViewEntity] | None: ...
 
-    def _load_implements(self, default_space: str, default_version: str) -> list[ViewEntity] | None:
+    @overload
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True]
+    ) -> list[ViewEntity | str] | None: ...
+
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True, False] = False
+    ) -> list[ViewEntity] | list[ViewEntity | str] | None:
         self.implements = self.implements.strip() if self.implements else None
 
         return (
             [
-                ViewEntity.load(implement, strict=True, space=default_space, version=default_version)
+                ViewEntity.load(
+                    implement,
+                    strict=True,
+                    space=default_space,
+                    version=default_version,
+                    return_on_failure=return_on_failure,
+                )
                 for implement in self.implements.split(",")
             ]
             if self.implements
@@ -361,7 +408,7 @@ class UnverifiedPhysicalNodeType(UnverifiedComponent[PhysicalNodeType]):
 
     def dump(self, default_space: str, **_) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Node"] = DMSNodeEntity.load(self.node, space=default_space)
+        output["Node"] = DMSNodeEntity.load(self.node, space=default_space, return_on_failure=True)
         return output
 
 
@@ -459,3 +506,52 @@ class UnverifiedPhysicalDataModel(UnverifiedDataModel[PhysicalDataModel]):
     def imported_views_and_containers_ids(self) -> tuple[set[ViewId], set[ContainerId]]:
         views, containers = self.imported_views_and_containers()
         return {view.as_id() for view in views}, {container.as_id() for container in containers}
+
+
+def _parse_constraints(
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None,
+    default_space: str | None = None,
+) -> list[ContainerConstraintEntity | PhysicalUnknownEntity] | None:
+    """Parse constraint input into a standardized list of ContainerConstraintEntity objects.
+
+    Args:
+        constraint: The constraint input in various formats
+        default_space: Default space to use when loading constraint entities
+
+    Returns:
+        List of parsed constraint entities, or None if no constraints
+    """
+    if constraint is None:
+        return None
+
+    if isinstance(constraint, ContainerConstraintEntity):
+        return [constraint]
+
+    if isinstance(constraint, str) and "," not in constraint:
+        return [ContainerConstraintEntity.load(constraint, return_on_failure=True, space=default_space)]
+
+    if isinstance(constraint, str):
+        return [
+            ContainerConstraintEntity.load(constraint_item.strip(), return_on_failure=True, space=default_space)
+            for constraint_item in SPLIT_ON_COMMA_PATTERN.split(constraint)
+            if constraint_item.strip()
+        ]
+
+    if isinstance(constraint, list):
+        constraint_list: list[ContainerConstraintEntity | PhysicalUnknownEntity] = []
+        for constraint_item in constraint:
+            if isinstance(constraint_item, ContainerConstraintEntity):
+                constraint_list.append(constraint_item)
+            elif isinstance(constraint_item, str):
+                constraint_list.extend(
+                    [
+                        ContainerConstraintEntity.load(idx.strip(), return_on_failure=True, space=default_space)
+                        for idx in SPLIT_ON_COMMA_PATTERN.split(constraint_item)
+                        if idx.strip()
+                    ]
+                )
+            else:
+                raise TypeError(f"Unexpected type for constraint: {type(constraint_item)}")
+        return constraint_list
+
+    raise TypeError(f"Unexpected type for constraint: {type(constraint)}")

cognite/neat/{core → _v0/core}/_data_model/models/physical/_validation.py

@@ -3,6 +3,7 @@ from collections import Counter, defaultdict
 from collections.abc import Mapping
 from dataclasses import dataclass
 from functools import lru_cache
+from typing import cast
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerList, ViewId, ViewList
@@ -13,25 +14,25 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._client.data_classes.data_modeling import ViewApplyDict
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import (
+from cognite.neat._v0.core._client import NeatClient
+from cognite.neat._v0.core._client.data_classes.data_modeling import ViewApplyDict
+from cognite.neat._v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat._v0.core._constants import (
     COGNITE_MODELS,
     COGNITE_SPACES,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
     DMS_VIEW_CONTAINER_SIZE_LIMIT,
     get_base_concepts,
 )
-from cognite.neat.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import ContainerEntity, RawFilter
-from cognite.neat.core._data_model.models.entities._single_value import (
+from cognite.neat._v0.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
+from cognite.neat._v0.core._data_model.models.data_types import DataType
+from cognite.neat._v0.core._data_model.models.entities import ContainerEntity, RawFilter
+from cognite.neat._v0.core._data_model.models.entities._single_value import (
     ContainerIndexEntity,
     ViewEntity,
 )
-from cognite.neat.core._issues import IssueList, NeatError
-from cognite.neat.core._issues.errors import (
+from cognite.neat._v0.core._issues import IssueList, NeatError
+from cognite.neat._v0.core._issues.errors import (
     CDFMissingClientError,
     PropertyDefinitionDuplicatedError,
     PropertyInvalidDefinitionError,
@@ -41,21 +42,21 @@ from cognite.neat.core._issues.errors import (
     ResourceNotFoundError,
     ReversedConnectionNotFeasibleError,
 )
-from cognite.neat.core._issues.errors._external import CDFMissingResourcesError
-from cognite.neat.core._issues.warnings import (
+from cognite.neat._v0.core._issues.errors._external import CDFMissingResourcesError
+from cognite.neat._v0.core._issues.warnings import (
     NotSupportedHasDataFilterLimitWarning,
     NotSupportedViewContainerLimitWarning,
     ReversedConnectionNotFeasibleWarning,
     UndefinedViewWarning,
     user_modeling,
 )
-from cognite.neat.core._issues.warnings._models import ViewWithoutPropertiesWarning
-from cognite.neat.core._issues.warnings.user_modeling import (
+from cognite.neat._v0.core._issues.warnings._models import ViewWithoutPropertiesWarning
+from cognite.neat._v0.core._issues.warnings.user_modeling import (
     ContainerPropertyLimitWarning,
     DirectRelationMissingSourceWarning,
     NotNeatSupportedFilterWarning,
 )
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat._v0.core._utils.text import humanize_collection
 
 from ._verified import PhysicalDataModel, PhysicalProperty
 
@@ -86,7 +87,7 @@ class PhysicalValidation:
         context: ImportContext | None = None,
     ) -> None:
         # import here to avoid circular import issues
-        from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
+        from cognite.neat._v0.core._data_model.analysis._base import DataModelAnalysis
 
         self._data_model = data_model
         self._client = client
@@ -121,9 +122,9 @@ class PhysicalValidation:
             view_with_properties.add(prop.view)
 
         for container in self._containers or []:
-            for required in container.constraint or []:
-                if required not in existing_containers:
-                    imported_containers.add(required)
+            for constraint in container.constraint or []:
+                if constraint.require not in existing_containers:
+                    imported_containers.add(cast(ContainerEntity, constraint.require))
 
         if include_views_with_no_properties:
             extra_views = existing_views - view_with_properties
@@ -470,8 +471,11 @@ class PhysicalValidation:
                     )
                 )
             constraint_definitions = {
-                ",".join(prop.constraint) for _, prop in properties if prop.constraint is not None
+                ",".join([str(constraint) for constraint in prop.constraint])
+                for _, prop in properties
+                if prop.constraint is not None
             }
+
             if len(constraint_definitions) > 1:
                 errors.append(
                     PropertyDefinitionDuplicatedError[dm.ContainerId](