cognite-neat 0.123.36__py3-none-any.whl → 0.123.38__py3-none-any.whl

cognite/neat/_data_model/models/conceptual/_base.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+from pydantic.alias_generators import to_camel
+
+from cognite.neat._data_model._identifiers import URI
+
+
+class BaseModelObject(BaseModel, alias_generator=to_camel, extra="ignore", populate_by_name=True):
+    """Base class for all object. This includes resources and nested objects."""
+
+    ...
+
+
+class ResourceMetadata(BaseModelObject):
+    name: str | None = Field(
+        None, description="Human readable / display name of resource being described.", max_length=1024
+    )
+    description: str | None = Field(None, description="The description of the resource.", max_length=255)
+    uri: URI | None = Field(None, description="The URI of the resource being described.")

cognite/neat/_data_model/models/conceptual/_properties.py

@@ -0,0 +1,104 @@
+from typing import Any
+
+from pydantic import Field, ValidationInfo, field_validator, model_validator
+
+from cognite.neat._data_model.models.entities import URI, ConceptEntity, DataType, UnknownEntity
+
+from ._base import ResourceMetadata
+
+
+class Property(ResourceMetadata):
+    value_type: DataType | ConceptEntity | UnknownEntity = Field(
+        union_mode="left_to_right",
+        description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
+    )
+    min_count: int | None = Field(
+        default=None,
+        ge=0,
+        description="Minimum number of values that the property can hold. "
+        "If no value is provided, the default value is None meaning `0`, "
+        "which means that the property is optional.",
+    )
+    max_count: int | None = Field(
+        default=None,
+        ge=0,
+        description="Maximum number of values that the property can hold. "
+        "If no value is provided, the default value is None meaning `inf`, "
+        "which means that the property can hold any number of values (listable).",
+    )
+    default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
+    instance_reference: list[URI] | None = Field(
+        default=None,
+        description="The URI(s) in the graph to get the value of the property.",
+    )
+
+    @model_validator(mode="after")
+    def check_min_max_count(self) -> "Property":
+        if self.min_count is not None and self.max_count is not None:
+            if self.min_count > self.max_count:
+                raise ValueError("min_count must be less than or equal to max_count")
+        return self
+
+    @field_validator("default", mode="after")
+    def check_default_value_primitive_type(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+        if not isinstance(value_type, DataType):
+            raise ValueError("Setting default value is only supported for primitive value types.")
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_python_type_exists(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+
+        if isinstance(value_type, DataType) and not hasattr(value_type, "python"):
+            raise ValueError(
+                f"DataType {value_type} does not have a python type defined."
+                " Setting default value for property is not possible."
+            )
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_not_list(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        if isinstance(value, list):
+            raise ValueError("Setting list as default value is not supported.")
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_single_valued(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        max_count = info.data.get("max_count")
+
+        if max_count is None or max_count > 1:
+            raise ValueError(
+                "Setting default value is only supported for single-valued properties."
+                f" Property has max_count={max_count or 'Inf'}."
+            )
+        return value
+
+    @field_validator("default", mode="after")
+    def check_default_value_type_match(cls, value: Any, info: ValidationInfo) -> Any:
+        if not value:
+            return value
+
+        value_type = info.data.get("value_type")
+
+        if (
+            isinstance(value_type, DataType)
+            and hasattr(value_type, "python")
+            and not isinstance(value, value_type.python)
+        ):
+            raise ValueError(
+                f"Default value type is {type(value)}, which does not match expected value type {value_type.python}."
+            )
+        return value

cognite/neat/_data_model/models/dms/__init__.py

@@ -1,10 +1,69 @@
-from ._base import Resource, WriteableResource
-from ._space import Space, SpaceRequest, SpaceResponse
+from cognite.neat._data_model.models.dms._base import Resource, WriteableResource
+from cognite.neat._data_model.models.dms._constraints import (
+    Constraint,
+    ConstraintDefinition,
+    RequiresConstraintDefinition,
+    UniquenessConstraintDefinition,
+)
+from cognite.neat._data_model.models.dms._container import (
+    Container,
+    ContainerPropertyDefinition,
+    ContainerRequest,
+    ContainerResponse,
+)
+from cognite.neat._data_model.models.dms._data_types import (
+    BooleanProperty,
+    DataType,
+    DateProperty,
+    DirectNodeRelation,
+    EnumProperty,
+    FileCDFExternalIdReference,
+    FloatProperty,
+    Int32Property,
+    Int64Property,
+    JSONProperty,
+    ListablePropertyTypeDefinition,
+    PropertyTypeDefinition,
+    SequenceCDFExternalIdReference,
+    TextProperty,
+    TimeseriesCDFExternalIdReference,
+    TimestampProperty,
+)
+from cognite.neat._data_model.models.dms._indexes import BtreeIndex, Index, IndexDefinition, InvertedIndex
+from cognite.neat._data_model.models.dms._space import Space, SpaceRequest, SpaceResponse
 
 __all__ = [
+    "BooleanProperty",
+    "BtreeIndex",
+    "Constraint",
+    "ConstraintDefinition",
+    "Container",
+    "ContainerPropertyDefinition",
+    "ContainerRequest",
+    "ContainerResponse",
+    "DataType",
+    "DateProperty",
+    "DirectNodeRelation",
+    "EnumProperty",
+    "FileCDFExternalIdReference",
+    "FloatProperty",
+    "Index",
+    "IndexDefinition",
+    "Int32Property",
+    "Int64Property",
+    "InvertedIndex",
+    "JSONProperty",
+    "ListablePropertyTypeDefinition",
+    "PropertyTypeDefinition",
+    "RequiresConstraintDefinition",
     "Resource",
+    "SequenceCDFExternalIdReference",
     "Space",
     "SpaceRequest",
     "SpaceResponse",
+    "TextProperty",
+    "TimeseriesCDFExternalIdReference",
+    "TimestampProperty",
+    "UniquenessConstraintDefinition",
     "WriteableResource",
 ]

cognite/neat/_data_model/models/dms/_constants.py

@@ -1,2 +1,46 @@
-SPACE_FORMAT_PATTERN = r"[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
+SPACE_FORMAT_PATTERN = r"^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
+DM_EXTERNAL_ID_PATTERN = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
+CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN = r"^[a-zA-Z0-9][a-zA-Z0-9_-]{0,253}[a-zA-Z0-9]?$"
+INSTANCE_ID_PATTERN = r"^[^\\x00]{1,256}$"
+ENUM_VALUE_IDENTIFIER_PATTERN = r"^[_A-Za-z][_0-9A-Za-z]{0,127}$"
+FORBIDDEN_ENUM_VALUES = frozenset({"true", "false", "null"})
 FORBIDDEN_SPACES = frozenset(["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"])
+FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS = frozenset(
+    [
+        "Query",
+        "Mutation",
+        "Subscription",
+        "String",
+        "Int32",
+        "Int64",
+        "Int",
+        "Float32",
+        "Float64",
+        "Float",
+        "Timestamp",
+        "JSONObject",
+        "Date",
+        "Numeric",
+        "Boolean",
+        "PageInfo",
+        "File",
+        "Sequence",
+        "TimeSeries",
+    ]
+)
+FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER = frozenset(
+    [
+        "space",
+        "externalId",
+        "createdTime",
+        "lastUpdatedTime",
+        "deletedTime",
+        "edge_id",
+        "node_id",
+        "project_id",
+        "property_group",
+        "seq",
+        "tg_table_name",
+        "extensions",
+    ]
+)

cognite/neat/_data_model/models/dms/_constraints.py

@@ -0,0 +1,30 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field
+
+from ._base import BaseModelObject
+from ._references import ContainerReference
+
+
+class ConstraintDefinition(BaseModelObject, ABC):
+    constraint_type: str
+
+
+class UniquenessConstraintDefinition(ConstraintDefinition):
+    constraint_type: Literal["uniqueness"] = "uniqueness"
+    properties: list[str] = Field(
+        description="List of properties included in the constraint.", min_length=1, max_length=10
+    )
+    by_space: bool | None = Field(default=None, description="Whether to make the constraint space-specific.")
+
+
+class RequiresConstraintDefinition(ConstraintDefinition):
+    constraint_type: Literal["requires"] = "requires"
+    require: ContainerReference = Field(description="Reference to an existing container.")
+
+
+Constraint = Annotated[
+    UniquenessConstraintDefinition | RequiresConstraintDefinition,
+    Field(discriminator="constraint_type"),
+]

cognite/neat/_data_model/models/dms/_container.py

@@ -0,0 +1,152 @@
+import re
+from abc import ABC
+from typing import Any, Literal
+
+from pydantic import Field, field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from cognite.neat._utils.text import humanize_collection
+
+from ._base import BaseModelObject, Resource, WriteableResource
+from ._constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS,
+    FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER,
+    SPACE_FORMAT_PATTERN,
+)
+from ._constraints import Constraint
+from ._data_types import DataType
+from ._indexes import Index
+
+KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
+
+
+class ContainerPropertyDefinition(BaseModelObject):
+    immutable: bool | None = Field(
+        default=None,
+        description="Should updates to this property be rejected after the initial population?",
+    )
+    nullable: bool | None = Field(
+        default=None,
+        description="Does this property need to be set to a value, or not?",
+    )
+    auto_increment: bool | None = Field(
+        default=None,
+        description="Increment the property based on its highest current value (max value).",
+    )
+    default_value: str | int | bool | dict[str, Any] | None = Field(
+        default=None,
+        description="Default value to use when you do not specify a value for the property.",
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property.",
+        max_length=1024,
+    )
+    name: str | None = Field(
+        default=None,
+        description="Readable property name.",
+        max_length=255,
+    )
+    type: DataType = Field(description="The type of data you can store in this property.")
+
+
+class Container(Resource, ABC):
+    space: str = Field(
+        description="The workspace for the container, a unique identifier for the space.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the container.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    name: str | None = Field(
+        default=None,
+        description="name for the container.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the container.",
+        max_length=1024,
+    )
+    used_for: Literal["node", "edge", "all"] | None = Field(
+        default=None,
+        description="Should this operation apply to nodes, edges or both.",
+    )
+    properties: dict[str, ContainerPropertyDefinition] = Field(
+        description="Set of properties to apply to the container.",
+        min_length=1,
+    )
+    constraints: dict[str, Constraint] | None = Field(
+        default=None,
+        description="Set of constraints to apply to the container.",
+        max_length=10,
+    )
+    indexes: dict[str, Index] | None = Field(
+        default=None,
+        description="Set of indexes to apply to the container.",
+        max_length=10,
+    )
+
+    @field_validator("indexes", "constraints", mode="after")
+    def validate_key_length(cls, val: dict[str, Any] | None, info: ValidationInfo) -> dict[str, Any] | None:
+        """Validate keys"""
+        if not isinstance(val, dict):
+            return val
+        invalid_keys = {key for key in val.keys() if not (1 <= len(key) <= 43)}
+        if invalid_keys:
+            raise ValueError(
+                f"{info.field_name} keys must be between 1 and 43 characters long. Invalid keys: "
+                f"{humanize_collection(invalid_keys)}"
+            )
+        return val
+
+    @field_validator("properties", mode="after")
+    def validate_property_keys(cls, val: dict[str, Any]) -> dict[str, Any]:
+        """Validate property keys"""
+        if invalid_keys := {key for key in val if not KEY_PATTERN.match(key)}:
+            raise ValueError(
+                f"Property keys must match pattern '{CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN}'. "
+                f"Invalid keys: {humanize_collection(invalid_keys)}"
+            )
+
+        if forbidden_keys := set(val.keys()).intersection(FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER):
+            raise ValueError(
+                f"Property keys cannot be any of the following reserved values: {humanize_collection(forbidden_keys)}"
+            )
+        return val
+
+    @field_validator("external_id")
+    def check_forbidden_external_id_value(cls, val: str) -> str:
+        """Check the external_id not present in forbidden set"""
+        if val in FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS:
+            raise ValueError(
+                f"{val!r} is a reserved container External ID. Reserved External IDs are: "
+                f"{humanize_collection(FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS)}"
+            )
+        return val
+
+
+class ContainerRequest(Container): ...
+
+
+class ContainerResponse(Container, WriteableResource[ContainerRequest]):
+    created_time: int = Field(
+        description="When the container was created. The number of milliseconds since 00:00:00 "
+        "Thursday, 1 January 1970, "
+        "Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    last_updated_time: int = Field(
+        description="When the container was last updated. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    is_global: bool = Field(description="Whether the container is a global container.")
+
+    def as_request(self) -> "ContainerRequest":
+        return ContainerRequest.model_validate(self.model_dump(by_alias=True))

cognite/neat/_data_model/models/dms/_data_types.py

@@ -0,0 +1,167 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, field_validator
+
+from cognite.neat._utils.text import humanize_collection
+
+from ._base import BaseModelObject
+from ._constants import ENUM_VALUE_IDENTIFIER_PATTERN, FORBIDDEN_ENUM_VALUES, INSTANCE_ID_PATTERN
+from ._references import ContainerReference
+
+
+class PropertyTypeDefinition(BaseModelObject, ABC):
+    type: str
+
+
+class ListablePropertyTypeDefinition(PropertyTypeDefinition, ABC):
+    list: bool | None = Field(
+        default=None,
+        description="Specifies that the data type is a list of values.",
+    )
+    max_list_size: int | None = Field(
+        default=None,
+        description="Specifies the maximum number of values in the list",
+    )
+
+
+class TextProperty(ListablePropertyTypeDefinition):
+    type: Literal["text"] = "text"
+    max_text_size: int | None = Field(
+        default=None,
+        description="Specifies the maximum size in bytes of the text property, when encoded with utf-8.",
+    )
+    collation: str | None = Field(
+        default=None,
+        description="he set of language specific rules - used when sorting text fields.",
+    )
+
+
+class Unit(BaseModelObject):
+    external_id: str = Field(
+        description="The external ID of the unit. Must match the unit in the Cognite Unit catalog.",
+        min_length=1,
+        max_length=256,
+        pattern=INSTANCE_ID_PATTERN,
+    )
+    source_unit: str | None = Field(
+        default=None,
+        description="The unit in the source system.",
+    )
+
+
+class FloatProperty(ListablePropertyTypeDefinition, ABC):
+    unit: Unit | None = Field(default=None, description="The unit of the data stored in this property")
+
+
+class Float32Property(FloatProperty):
+    type: Literal["float32"] = "float32"
+
+
+class Float64Property(FloatProperty):
+    type: Literal["float64"] = "float64"
+
+
+class BooleanProperty(ListablePropertyTypeDefinition):
+    type: Literal["boolean"] = "boolean"
+
+
+class Int32Property(ListablePropertyTypeDefinition):
+    type: Literal["int32"] = "int32"
+
+
+class Int64Property(ListablePropertyTypeDefinition):
+    type: Literal["int64"] = "int64"
+
+
+class TimestampProperty(ListablePropertyTypeDefinition):
+    type: Literal["timestamp"] = "timestamp"
+
+
+class DateProperty(ListablePropertyTypeDefinition):
+    type: Literal["date"] = "date"
+
+
+class JSONProperty(ListablePropertyTypeDefinition):
+    type: Literal["json"] = "json"
+
+
+class TimeseriesCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["timeseries"] = "timeseries"
+
+
+class FileCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["file"] = "file"
+
+
+class SequenceCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["sequence"] = "sequence"
+
+
+class DirectNodeRelation(ListablePropertyTypeDefinition):
+    type: Literal["direct"] = "direct"
+    container: ContainerReference | None = Field(
+        default=None,
+        description="The (optional) required type for the node the direct relation points to.  If specified, "
+        "the node must exist before the direct relation is referenced and of the specified type. "
+        "If no container specification is used, the node will be auto created with the built-in node "
+        "container type, and it does not explicitly have to be created before the node that references it.",
+    )
+
+
+class EnumValue(BaseModelObject):
+    name: str | None = Field(
+        max_length=255,
+        description="The name of the enum value.",
+    )
+    description: str | None = Field(
+        default=None,
+        max_length=1024,
+        description="Description of the enum value.",
+    )
+
+
+class EnumProperty(PropertyTypeDefinition):
+    type: Literal["enum"] = "enum"
+    unknown_value: str | None = Field(
+        default=None,
+        description="TThe value to use when the enum value is unknown. This can optionally be used to "
+        "provide forward-compatibility, Specifying what value to use if the client does not "
+        "recognize the returned value. It is not possible to ingest the unknown value, "
+        "but it must be part of the allowed values.",
+    )
+    values: dict[str, EnumValue] = Field(
+        description="A set of all possible values for the enum property.",
+        min_length=1,
+        max_length=32,
+        pattern=ENUM_VALUE_IDENTIFIER_PATTERN,
+    )
+
+    @field_validator("values", mode="after")
+    def _valid_enum_value(cls, val: dict[str, EnumValue]) -> dict[str, EnumValue]:
+        invalid_enum_values = set(val.keys()).intersection(FORBIDDEN_ENUM_VALUES)
+        if invalid_enum_values:
+            raise ValueError(
+                "Enum values cannot be any of the following reserved values: "
+                f"{humanize_collection(invalid_enum_values)}"
+            )
+        return val
+
+
+DataType = Annotated[
+    TextProperty
+    | Float32Property
+    | Float64Property
+    | BooleanProperty
+    | Int32Property
+    | Int64Property
+    | TimestampProperty
+    | DateProperty
+    | JSONProperty
+    | TimeseriesCDFExternalIdReference
+    | FileCDFExternalIdReference
+    | SequenceCDFExternalIdReference
+    | DirectNodeRelation
+    | EnumProperty,
+    Field(discriminator="type"),
+]

cognite/neat/_data_model/models/dms/_indexes.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field
+
+from ._base import BaseModelObject
+
+
+class IndexDefinition(BaseModelObject, ABC):
+    index_type: str
+    properties: list[str] = Field(description="List of properties to define the index across.")
+
+
+class BtreeIndex(IndexDefinition):
+    index_type: Literal["btree"] = "btree"
+    by_space: bool | None = Field(default=None, description="Whether to make the index space-specific.")
+    cursorable: bool | None = Field(
+        default=None, description="Whether the index can be used for cursor-based pagination."
+    )
+
+
+class InvertedIndex(IndexDefinition):
+    index_type: Literal["inverted"] = "inverted"
+
+
+Index = Annotated[BtreeIndex | InvertedIndex, Field(discriminator="index_type")]

cognite/neat/_data_model/models/dms/_references.py

@@ -0,0 +1,22 @@
+from typing import Literal
+
+from pydantic import Field
+
+from ._base import BaseModelObject
+from ._constants import DM_EXTERNAL_ID_PATTERN, SPACE_FORMAT_PATTERN
+
+
+class ContainerReference(BaseModelObject):
+    type: Literal["container"] = "container"
+    space: str = Field(
+        description="Id of the space hosting (containing) the container.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the container.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )

cognite/neat/_data_model/models/dms/_space.py

@@ -15,8 +15,8 @@ class Space(WriteableResource["SpaceRequest"], ABC):
         max_length=43,
         pattern=SPACE_FORMAT_PATTERN,
     )
-    name: str | None = Field(None, description="Name of the space.", max_length=1024)
-    description: str | None = Field(None, description="The description of the space.", max_length=255)
+    name: str | None = Field(None, description="Name of the space.", max_length=255)
+    description: str | None = Field(None, description="The description of the space.", max_length=1024)
 
     @field_validator("space")
     def check_forbidden_space_value(cls, val: str) -> str:

cognite/neat/_data_model/models/entities/__init__.py

@@ -1,3 +1,4 @@
+from ._base import ConceptEntity, UnknownEntity
 from ._constants import Undefined, Unknown
 from ._data_types import (
     AnyURI,
@@ -24,6 +25,7 @@ __all__ = [
     "URI",
     "AnyURI",
     "Boolean",
+    "ConceptEntity",
     "DataType",
     "Date",
     "DateTime",
@@ -42,5 +44,6 @@ __all__ = [
     "Timeseries",
     "Undefined",
     "Unknown",
+    "UnknownEntity",
     "parse_entity",
 ]

cognite/neat/_issues.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+
+
+class ModelSyntaxError(BaseModel):
+    """If any syntax error is found. Stop validation
+    and ask user to fix the syntax error first."""
+
+    message: str
+
+
+class ImplementationWarning(BaseModel):
+    """This is only for conceptual data model. It means that conversion to DMS
+    will fail unless user implements the missing part."""
+
+    message: str
+    fix: str
+
+
+class ConsistencyError(BaseModel):
+    """If any consistency error is found, the deployment of the data model will fail. For example,
+    if a reverse direct relations points to a non-existing direct relation. This is only relevant for
+    DMS model.
+    """
+
+    message: str
+    fix: str
+
+
+class Recommendation(BaseModel):
+    """Best practice recommendation."""
+
+    message: str
+    fix: str | None = None

cognite/neat/_utils/text.py

@@ -0,0 +1,40 @@
+from collections.abc import Collection
+from typing import Any
+
+
+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:
+        return str(next(iter(collection)))
+
+    strings = (str(item) for item in collection)
+    if sort:
+        sequence = sorted(strings)
+    else:
+        sequence = list(strings)
+
+    return f"{', '.join(sequence[:-1])} {bind_word} {sequence[-1]}"

cognite/neat/_utils/validation.py

@@ -0,0 +1,81 @@
+from pydantic import ValidationError
+from pydantic_core import ErrorDetails
+
+
+def humanize_validation_error(error: ValidationError) -> list[str]:
+    """Converts a ValidationError to a human-readable format.
+
+    This overwrites the default error messages from Pydantic to be better suited for Toolkit users.
+
+    Args:
+        error: The ValidationError to convert.
+
+    Returns:
+        A list of human-readable error messages.
+    """
+    errors: list[str] = []
+    item: ErrorDetails
+
+    for item in error.errors(include_input=True, include_url=False):
+        loc = item["loc"]
+        error_type = item["type"]
+        if error_type == "missing":
+            msg = f"Missing required field: {loc[-1]!r}"
+        elif error_type == "extra_forbidden":
+            msg = f"Unused field: {loc[-1]!r}"
+        elif error_type == "value_error":
+            msg = str(item["ctx"]["error"])
+        elif error_type == "literal_error":
+            msg = f"{item['msg']}. Got {item['input']!r}."
+        elif error_type == "string_type":
+            msg = (
+                f"{item['msg']}. Got {item['input']!r} of type {type(item['input']).__name__}. "
+                f"Hint: Use double quotes to force string."
+            )
+        elif error_type == "model_type":
+            model_name = item["ctx"].get("class_name", "unknown")
+            msg = (
+                f"Input must be an object of type {model_name}. Got {item['input']!r} of "
+                f"type {type(item['input']).__name__}."
+            )
+        elif error_type.endswith("_type"):
+            msg = f"{item['msg']}. Got {item['input']!r} of type {type(item['input']).__name__}."
+        else:
+            # Default to the Pydantic error message
+            msg = item["msg"]
+
+        if error_type.endswith("dict_type") and len(loc) > 1:
+            # If this is a dict_type error for a JSON field, the location will be:
+            #  dict[str,json-or-python[json=any,python=tagged-union[list[...],dict[str,...],str,bool,int,float,none]]]
+            #  This is hard to read, so we simplify it to just the field name.
+            loc = tuple(["dict" if isinstance(x, str) and "json-or-python" in x else x for x in loc])
+
+        if len(loc) > 1 and error_type in {"extra_forbidden", "missing"}:
+            # We skip the last element as this is in the message already
+            msg = f"In {as_json_path(loc[:-1])} {msg[:1].casefold()}{msg[1:]}"
+        elif len(loc) > 1:
+            msg = f"In {as_json_path(loc)} {msg[:1].casefold()}{msg[1:]}"
+        elif len(loc) == 1 and isinstance(loc[0], str) and error_type not in {"extra_forbidden", "missing"}:
+            msg = f"In field {loc[0]} {msg[:1].casefold()}{msg[1:]}"
+        errors.append(msg)
+    return errors
+
+
+def as_json_path(loc: tuple[str | int, ...]) -> str:
+    """Converts a location tuple to a JSON path.
+
+    Args:
+        loc: The location tuple to convert.
+
+    Returns:
+        A JSON path string.
+    """
+    if not loc:
+        return ""
+    # +1 to convert from 0-based to 1-based indexing
+    prefix = ""
+    if isinstance(loc[0], int):
+        prefix = "item "
+
+    suffix = ".".join([str(x) if isinstance(x, str) else f"[{x + 1}]" for x in loc]).replace(".[", "[")
+    return f"{prefix}{suffix}"

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.36"
+__version__ = "0.123.38"
 __engine__ = "^2.0.4"

cognite/neat/v0/core/_data_model/exporters/__init__.py

@@ -2,7 +2,7 @@ from ._base import BaseExporter, CDFExporter
 from ._data_model2dms import DMSExporter
 from ._data_model2excel import ExcelExporter
 from ._data_model2instance_template import InstanceTemplateExporter
-from ._data_model2ontology import GraphExporter, OWLExporter, SemanticDataModelExporter, SHACLExporter
+from ._data_model2semantic_model import GraphExporter, OWLExporter, SHACLExporter
 from ._data_model2yaml import YAMLExporter
 
 __all__ = [
@@ -14,7 +14,6 @@ __all__ = [
     "InstanceTemplateExporter",
     "OWLExporter",
     "SHACLExporter",
-    "SemanticDataModelExporter",
     "YAMLExporter",
 ]
 

cognite/neat/v0/core/_data_model/exporters/{_data_model2ontology.py → _data_model2semantic_model.py}

@@ -32,6 +32,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
+SHACL = Namespace("http://www.w3.org/ns/shacl#")
+
 
 class GraphExporter(BaseExporter[ConceptualDataModel, Graph], ABC):
     def export_to_file(self, data_model: ConceptualDataModel, filepath: Path) -> None:
@@ -42,7 +44,7 @@ class OWLExporter(GraphExporter):
     """Exports verified conceptual data model to an OWL ontology."""
 
     def export(self, data_model: ConceptualDataModel) -> Graph:
-        return Ontology.from_data_model(data_model).as_owl()
+        return Ontology.from_data_model(data_model).graph
 
     @property
     def description(self) -> str:
@@ -53,44 +55,31 @@ class SHACLExporter(GraphExporter):
     """Exports data_model to a SHACL graph."""
 
     def export(self, data_model: ConceptualDataModel) -> Graph:
-        return Ontology.from_data_model(data_model).as_shacl()
-
-    @property
-    def description(self) -> str:
-        return "Export verified information model to SHACL."
-
-
-class SemanticDataModelExporter(GraphExporter):
-    """Exports verified information model to a semantic data model."""
-
-    def export(self, data_model: ConceptualDataModel) -> Graph:
-        return Ontology.from_data_model(data_model).as_semantic_data_model()
+        return ShaclShapes.from_data_model(data_model).graph
 
     @property
     def description(self) -> str:
-        return "Export verified information model to a semantic data model."
+        return "Export verified conceptual data model to SHACL."
 
 
-class OntologyModel(BaseModel):
+class _ModelConfig(BaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, strict=False, extra="allow")
 
 
-class Ontology(OntologyModel):
+class Ontology(_ModelConfig):
     """
     Represents an ontology. This class is used to generate an OWL ontology from conceptual data model.
 
     Args:
         properties: A list of OWL properties.
         classes: A list of OWL classes.
-        shapes: A list of SHACL node shapes.
         metadata: Metadata about the ontology.
         prefixes: A dictionary of prefixes and namespaces.
     """
 
+    metadata: "OWLMetadata"
     properties: list["OWLProperty"]
     classes: list["OWLClass"]
-    shapes: list["SHACLNodeShape"]
-    metadata: "OWLMetadata"
     prefixes: dict[str, Namespace]
 
     @classmethod
@@ -105,7 +94,6 @@ class Ontology(OntologyModel):
             An instance of Ontology.
         """
         analysis = DataModelAnalysis(data_model)
-        concept_by_suffix = analysis.concept_by_suffix()
         return cls(
             properties=[
                 OWLProperty.from_list_of_properties(definition, data_model.metadata.namespace)
@@ -115,46 +103,12 @@ class Ontology(OntologyModel):
                 OWLClass.from_concept(definition, data_model.metadata.namespace, data_model.prefixes)
                 for definition in data_model.concepts
             ],
-            shapes=[
-                SHACLNodeShape.from_data_model(
-                    concept_by_suffix[str(concept.suffix)],
-                    list(properties.values()),
-                    data_model.metadata.namespace,
-                )
-                for concept, properties in analysis.properties_by_id_by_concept().items()
-            ]
-            + [
-                SHACLNodeShape.from_data_model(
-                    concept,
-                    [],
-                    data_model.metadata.namespace,
-                )
-                for concept in concept_by_suffix.values()
-            ],
             metadata=OWLMetadata(**data_model.metadata.model_dump()),
             prefixes=data_model.prefixes,
         )
 
-    def as_shacl(self) -> Graph:
-        """
-        Generates a SHACL graph from the ontology.
-
-        Returns:
-            A SHACL graph.
-        """
-
-        shacl = Graph()
-        shacl.bind(self.metadata.prefix, self.metadata.namespace)
-        for prefix, namespace in self.prefixes.items():
-            shacl.bind(prefix, namespace)
-
-        for shape in self.shapes:
-            for triple in shape.triples:
-                shacl.add(triple)  # type: ignore[arg-type]
-
-        return shacl
-
-    def as_owl(self) -> Graph:
+    @property
+    def graph(self) -> Graph:
         """
         Generates an OWL graph from the ontology.
 
@@ -180,33 +134,6 @@ class Ontology(OntologyModel):
 
         return owl
 
-    def as_semantic_data_model(self) -> Graph:
-        return self.as_owl() + self.as_shacl()
-
-    @property
-    def owl_triples(self) -> list[tuple]:
-        return list(self.as_owl())
-
-    @property
-    def shacl_triples(self) -> list[tuple]:
-        return list(self.as_shacl())
-
-    @property
-    def triples(self) -> list[tuple]:
-        return self.owl_triples + self.shacl_triples
-
-    @property
-    def ontology(self) -> str:
-        return self.as_owl().serialize()
-
-    @property
-    def constraints(self) -> str:
-        return self.as_shacl().serialize()
-
-    @property
-    def semantic_data_model(self) -> str:
-        return (self.as_owl() + self.as_shacl()).serialize()
-
 
 class OWLMetadata(ConceptualMetadata):
     @property
@@ -233,7 +160,7 @@ class OWLMetadata(ConceptualMetadata):
         return triples
 
 
-class OWLClass(OntologyModel):
+class OWLClass(_ModelConfig):
     id_: URIRef
     type_: URIRef = OWL.Class
     label: str | None
@@ -306,7 +233,7 @@ class OWLClass(OntologyModel):
         )
 
 
-class OWLProperty(OntologyModel):
+class OWLProperty(_ModelConfig):
     id_: URIRef
     type_: set[URIRef]
     label: set[str]
@@ -510,10 +437,78 @@ class OWLProperty(OntologyModel):
         )
 
 
-SHACL = Namespace("http://www.w3.org/ns/shacl#")
+class ShaclShapes(_ModelConfig):
+    """
+    Represents a SHACL shapes. This class is used to generate a SHACL graph from conceptual data model.
+
+    Args:
+        shapes: A list of SHACL node shapes.
+        prefixes: A dictionary of prefixes and namespaces.
+    """
 
+    shapes: list["SHACLNodeShape"]
+    prefixes: dict[str, Namespace]
 
-class SHACLNodeShape(OntologyModel):
+    @classmethod
+    def from_data_model(cls, data_model: ConceptualDataModel) -> Self:
+        """
+        Generates shacl shapes from a conceptual data model.
+
+        Args:
+            data_model: The data_model to generate the shacl shapes from.
+
+        Returns:
+            An instance of ShaclShapes.
+        """
+        analysis = DataModelAnalysis(data_model)
+        concepts_by_concept_entity = analysis.concept_by_concept_entity
+        properties_by_concept_entity = analysis.properties_by_concepts()
+        return cls(
+            shapes=[
+                # shapes that have property shapes as well
+                SHACLNodeShape.from_concept(
+                    concept_entity,
+                    concepts_by_concept_entity,
+                    properties,
+                    data_model.metadata.namespace,
+                )
+                for concept_entity, properties in properties_by_concept_entity.items()
+            ]
+            + [
+                # shapes without any property shapes
+                SHACLNodeShape.from_concept(
+                    concept_entity,
+                    concepts_by_concept_entity,
+                    [],
+                    data_model.metadata.namespace,
+                )
+                for concept_entity in concepts_by_concept_entity.keys()
+                if concept_entity not in properties_by_concept_entity
+            ],
+            prefixes=data_model.prefixes,
+        )
+
+    @property
+    def graph(self) -> Graph:
+        """
+        Generates a SHACL graph from the class instance.
+
+        Returns:
+            A SHACL graph.
+        """
+
+        shacl = Graph()
+        for prefix, namespace in self.prefixes.items():
+            shacl.bind(prefix, namespace)
+
+        for shape in self.shapes:
+            for triple in shape.triples:
+                shacl.add(triple)  # type: ignore[arg-type]
+
+        return shacl
+
+
+class SHACLNodeShape(_ModelConfig):
     id_: URIRef
     type_: URIRef = SHACL.NodeShape
     target_class: URIRef
@@ -555,26 +550,33 @@ class SHACLNodeShape(OntologyModel):
         )
 
     @classmethod
-    def from_data_model(
+    def from_concept(
         cls,
-        concept_definition: Concept,
-        property_definitions: list[ConceptualProperty],
+        concept_entity: ConceptEntity,
+        concepts_by_concept_entity: dict[ConceptEntity, Concept],
+        properties: list[ConceptualProperty],
         namespace: Namespace,
     ) -> "SHACLNodeShape":
-        if concept_definition.implements:
-            parent = [namespace[str(parent.suffix) + "Shape"] for parent in concept_definition.implements]
+        if not (concept := concepts_by_concept_entity.get(concept_entity)):
+            raise ValueError(f"Concept {concept_entity} not found in data model!")
+
+        if concept.implements:
+            parent = [namespace[str(parent.suffix) + "Shape"] for parent in concept.implements]
         else:
             parent = None
         return cls(
-            id_=namespace[f"{concept_definition.concept.suffix!s}Shape"],
-            target_class=namespace[str(concept_definition.concept.suffix)],
+            id_=namespace[f"{concept.concept.suffix!s}Shape"],
+            target_class=concept.instance_source or namespace[str(concept.concept.suffix)],
             parent=parent,
-            property_shapes=[SHACLPropertyShape.from_property(prop, namespace) for prop in property_definitions],
+            property_shapes=[
+                SHACLPropertyShape.from_property(property_, concepts_by_concept_entity, namespace)
+                for property_ in properties
+            ],
             namespace=namespace,
         )
 
 
-class SHACLPropertyShape(OntologyModel):
+class SHACLPropertyShape(_ModelConfig):
     id_: BNode
     type_: URIRef = SHACL.property
     path: URIRef  # URIRef to property in OWL
@@ -614,23 +616,31 @@ class SHACLPropertyShape(OntologyModel):
         return self.path_triples + self.node_kind_triples + self.cardinality_triples
 
     @classmethod
-    def from_property(cls, definition: ConceptualProperty, namespace: Namespace) -> "SHACLPropertyShape":
-        # TODO requires PR to fix MultiValueType and UnknownValueType
-        if isinstance(definition.value_type, ConceptEntity):
-            expected_value_type = namespace[f"{definition.value_type.suffix}Shape"]
-        elif isinstance(definition.value_type, DataType):
-            expected_value_type = XSD[definition.value_type.xsd]
+    def from_property(
+        cls,
+        property_: ConceptualProperty,
+        concepts_by_concept_entity: dict[ConceptEntity, Concept],
+        namespace: Namespace,
+    ) -> "SHACLPropertyShape":
+        if isinstance(property_.value_type, ConceptEntity):
+            concept = concepts_by_concept_entity.get(property_.value_type)
+            value_type_uri = concept.instance_source if concept else None
+            expected_value_type = value_type_uri or namespace[f"{property_.value_type.suffix}"]
+        elif isinstance(property_.value_type, DataType):
+            expected_value_type = XSD[property_.value_type.xsd]
         else:
-            raise ValueError(f"Value type {definition.value_type.type_} is not supported")
+            raise NotImplementedError(f"Value type {property_.value_type.type_} is not supported yet")
 
         return cls(
             id_=BNode(),
-            path=namespace[definition.property_],
-            node_kind=SHACL.IRI if definition.type_ == EntityTypes.object_property else SHACL.Literal,
+            path=property_.instance_source[0]
+            if property_.instance_source and len(property_.instance_source) == 1
+            else namespace[property_.property_],
+            node_kind=SHACL.IRI if property_.type_ == EntityTypes.object_property else SHACL.Literal,
             expected_value_type=expected_value_type,
-            min_count=definition.min_count,
+            min_count=property_.min_count,
             max_count=(
-                int(definition.max_count) if definition.max_count and definition.max_count != float("inf") else None
+                int(property_.max_count) if property_.max_count and property_.max_count != float("inf") else None
             ),
             namespace=namespace,
         )

{cognite_neat-0.123.36.dist-info → cognite_neat-0.123.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.36
+Version: 0.123.38
 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.36.dist-info → cognite_neat-0.123.38.dist-info}/RECORD

@@ -1,15 +1,24 @@
 cognite/neat/__init__.py,sha256=Lo4DbjDOwnhCYUoAgPp5RG1fDdF7OlnomalTe7n1ydw,211
-cognite/neat/_version.py,sha256=jaav_lFeEoGh_VeTDKjQPDYC__mrYSbc7TXSKhz9g7c,47
+cognite/neat/_issues.py,sha256=uv0fkkWwTKqNmTmHqyoBB3L6yMCh42EZpEkLGmIJYOY,812
+cognite/neat/_version.py,sha256=AcC3bBw58APEu-16ayi6h9wHbjFkLKdwAnhBj7XMeqk,47
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/_constants.py,sha256=NGGvWHlQqhkkSBP_AqoofGYjNph3SiZX6QPINlMsy04,107
 cognite/neat/_data_model/_identifiers.py,sha256=a0LcQ_h0NffxSKTCrzCDpYkrlaUTk-D_rfaQUh-BhWc,1921
 cognite/neat/_data_model/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/_data_model/models/dms/__init__.py,sha256=LwuPR4zOPinhT89mN0XEB38d5deWmLbGFs_RvENVQlc,212
+cognite/neat/_data_model/models/conceptual/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/models/conceptual/_base.py,sha256=SFkoBJDM51pqew_isHFJoB20OgfofpwVRnTrg-rKkNY,710
+cognite/neat/_data_model/models/conceptual/_properties.py,sha256=CpF37vJYBTLT4DH4ZOu2U-JyWtkb_27V8fw52qiaE_k,4007
+cognite/neat/_data_model/models/dms/__init__.py,sha256=0YalizBE9PK_5JtzG1_fhrRhrRuqCUsWwWBkY4X4PHo,1876
 cognite/neat/_data_model/models/dms/_base.py,sha256=R8SP3Zi9daTBqewYKGjuNEkrWc-j91f-6t34CN-9YJ0,719
-cognite/neat/_data_model/models/dms/_constants.py,sha256=TpnOZ5Q1O_r2H5Ez3sAvaCH2s5DbnUm0qeRC-K1iPAQ,164
-cognite/neat/_data_model/models/dms/_space.py,sha256=bLSTY5tTBnvS19kUacxM0p_c22lYY5FY9etofH1NNMc,1680
-cognite/neat/_data_model/models/entities/__init__.py,sha256=yZSlicz9g2j4PCUW9h4KDwBhfApYb6jI0341HSWewT8,708
+cognite/neat/_data_model/models/dms/_constants.py,sha256=tLyle1N_ekNBhANleG7GvZB85P4uGaoWl2mqeR-vfmY,1272
+cognite/neat/_data_model/models/dms/_constraints.py,sha256=7Nv-EoNl6lSHUQh6r15Ei0LzR3gWV006K3RlAi1Ic68,956
+cognite/neat/_data_model/models/dms/_container.py,sha256=ovyAwsh2ACt0j9-j6ooDOdUl0uKlGdkjYA2UUvJfHrw,5756
+cognite/neat/_data_model/models/dms/_data_types.py,sha256=XSGQWVzYFRYAzKsDln20nC2kqiHQC6JAvDeTzCBPT-0,5202
+cognite/neat/_data_model/models/dms/_indexes.py,sha256=MsiHbGCH50QaF1mw_pIY-AZ5dY37vS3fQECOd2rBXWo,780
+cognite/neat/_data_model/models/dms/_references.py,sha256=yrmMo2JNfupG3tppdjLOaEhUAsRSIjZlBOI6hCol1z4,613
+cognite/neat/_data_model/models/dms/_space.py,sha256=-1LkRmQaAdIj2EYDcVv5Mcejl5uswgAEVv7DztpIUk4,1680
+cognite/neat/_data_model/models/entities/__init__.py,sha256=qdtIpyy2hjfdMwEHya-efOCvWassaalQla15RnqK00E,798
 cognite/neat/_data_model/models/entities/_base.py,sha256=PREgBqc6DM9pLn3VXFWxPBMVK0sexl6s3twSHn9wsf0,3874
 cognite/neat/_data_model/models/entities/_constants.py,sha256=P56zgsL2xqfegWOxEAyPm9qrZcxrjb1ZXqMG7cDmQxc,333
 cognite/neat/_data_model/models/entities/_data_types.py,sha256=DfdEWGek7gODro-_0SiiInhPGwul4zn-ASACQfn8HUY,2838
@@ -17,7 +26,9 @@ cognite/neat/_data_model/models/entities/_identifiers.py,sha256=uBiK4ot3V0b_LGXu
 cognite/neat/_data_model/models/entities/_parser.py,sha256=ZLGw0cFV-B7JuaAUJ65Jbjf6o-vidz9_BZvilS6lAZw,6455
 cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_utils/auxiliary.py,sha256=Cx-LP8dfN782R3iUcm--q26zdzQ0k_RFnVbJ0bwVZMI,1345
+cognite/neat/_utils/text.py,sha256=1el5Ty1T0tdhTF0gp6L8AAzUxaFmAUAIFy_VvfG_kkM,1194
 cognite/neat/_utils/useful_types.py,sha256=6Fpw_HlWFj8ZYjGPd0KzguBczuI8GFhj5wBceGsaeak,211
+cognite/neat/_utils/validation.py,sha256=qBC3V3BpkZSrsDG4xfINaB_U0e05e2lCt85oIW3on4I,3253
 cognite/neat/_utils/http_client/__init__.py,sha256=gJBrOH1tIzEzLforHbeakYimTn4RlelyANps-jtpREI,894
 cognite/neat/_utils/http_client/_client.py,sha256=2RVwTbbPFlQ8eJVLKNUXwnc4Yq_783PkY44zwr6LlT8,11509
 cognite/neat/_utils/http_client/_config.py,sha256=C8IF1JoijmVMjA_FEMgAkiD1buEV1cY5Og3t-Ecyfmk,756
@@ -50,12 +61,12 @@ cognite/neat/v0/core/_data_model/catalog/__init__.py,sha256=zWG1-GONe8m05lV3gLAK
 cognite/neat/v0/core/_data_model/catalog/classic_model.xlsx,sha256=YkocpkKypizjsWYwOdn5yzIz_BSl8T8SQLxgm4GIjLQ,15014
 cognite/neat/v0/core/_data_model/catalog/conceptual-imf-data-model.xlsx,sha256=vrE5g8vBtsGpwJqygxG3t9I3x4SUAyQsi1vtWfZ8QW4,53682
 cognite/neat/v0/core/_data_model/catalog/hello_world_pump.xlsx,sha256=E63t5U1PQLIoUfXp1mEuhuq8I2TGKovZlEfIhO5bevw,23322
-cognite/neat/v0/core/_data_model/exporters/__init__.py,sha256=6UbiK-dzVUCtYo09s8ICe36BbqPCur6OWB71Lwiu50U,1207
+cognite/neat/v0/core/_data_model/exporters/__init__.py,sha256=NSTeVtfgfkfrhf_Ruz5rHnlF0wIj2dIhAm3io1tEIkQ,1153
 cognite/neat/v0/core/_data_model/exporters/_base.py,sha256=pdtQDi5G89JVbHtGnvLHJDoujT1UVaCBw939Re1Gqv4,2412
 cognite/neat/v0/core/_data_model/exporters/_data_model2dms.py,sha256=LdLGgR73n9k5hHiWUSdvDc0lmaEO8UVQYFTiaVWHQ-c,19918
 cognite/neat/v0/core/_data_model/exporters/_data_model2excel.py,sha256=dT7ZHt57y3mca4TtCBnqMER0xlB7AyvivG0EZ2bGPzg,25484
 cognite/neat/v0/core/_data_model/exporters/_data_model2instance_template.py,sha256=cmyQBlc1UM5l42g1N_F2K1sVu39ontsmA2bfXJO5muQ,6115
-cognite/neat/v0/core/_data_model/exporters/_data_model2ontology.py,sha256=H12y7hZf9169xuVOnIIDnmvpNOegrTOESfG4-yoGpDw,22642
+cognite/neat/v0/core/_data_model/exporters/_data_model2semantic_model.py,sha256=vxeDEWyvj7uv6geNlTQe6MfGcNZkeQJYz0vLzPI7e14,23154
 cognite/neat/v0/core/_data_model/exporters/_data_model2yaml.py,sha256=v7CgNVtVv4t0FXHPJM-HGkID0AqVDlwsQqUNjWqr_1U,3287
 cognite/neat/v0/core/_data_model/importers/__init__.py,sha256=jkDKSGv5VdJgl44lmn7VQtD6-rqo09VFOr-tTB5Lfyc,1290
 cognite/neat/v0/core/_data_model/importers/_base.py,sha256=SAC3nhJUBBl5PwnIs-bQvVam_0zEGjlOlNMvVOuJZzI,2028
@@ -212,7 +223,7 @@ cognite/neat/v0/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4
 cognite/neat/v0/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/v0/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/v0/session/engine/_load.py,sha256=u0x7vuQCRoNcPt25KJBJRn8sJabonYK4vtSZpiTdP4k,5201
-cognite_neat-0.123.36.dist-info/METADATA,sha256=6blXCoQDpvS6J53dTnL1gs756MQJTNF5h3O3EyDdDvY,9148
-cognite_neat-0.123.36.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.36.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.36.dist-info/RECORD,,
+cognite_neat-0.123.38.dist-info/METADATA,sha256=iDFSXJ075Uh7qGQoJ-CP6VsKePjEuOdiKjf45BFYKWQ,9148
+cognite_neat-0.123.38.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.38.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.38.dist-info/RECORD,,