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

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

@@ -0,0 +1,67 @@
+from collections import Counter
+
+from pydantic import Field, ValidationInfo, field_validator
+from pyparsing import cast
+
+from cognite.neat._data_model.models.entities import ConceptEntity
+from cognite.neat._data_model.models.entities._constants import PREFIX_PATTERN, SUFFIX_PATTERN, VERSION_PATTERN
+from cognite.neat._utils.text import humanize_collection
+
+from ._base import ResourceMetadata
+from ._property import Property
+
+
+class Concept(ResourceMetadata):
+    space: str = Field(
+        description="Id of the space that the concept belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=PREFIX_PATTERN,
+        alias="prefix",
+    )
+    external_id: str = Field(
+        description="External-id of the concept.",
+        min_length=1,
+        max_length=255,
+        pattern=SUFFIX_PATTERN,
+        alias="suffix",
+    )
+    version: str | None = Field(
+        default=None,
+        description="Version of the concept.",
+        max_length=43,
+        pattern=VERSION_PATTERN,
+    )
+
+    implements: list[ConceptEntity] | None = Field(
+        default=None,
+        description="References to the concepts from where this concept will inherit properties.",
+    )
+
+    properties: dict[str, Property] | None = Field(default=None, description="Properties associated with the concept.")
+
+    @field_validator("implements", mode="after")
+    def cannot_implement_itself(cls, value: list[ConceptEntity], info: ValidationInfo) -> list[ConceptEntity]:
+        if not value:
+            return value
+
+        this_concept = ConceptEntity(
+            prefix=info.data["space"],
+            suffix=info.data["external_id"],
+            version=cast(str, info.data.get("version")),
+        )
+
+        if this_concept in value:
+            raise ValueError("A concept cannot implement itself.")
+
+        return value
+
+    @field_validator("implements", mode="after")
+    def cannot_have_duplicates(cls, value: list[ConceptEntity], info: ValidationInfo) -> list[ConceptEntity]:
+        counts = Counter(value)
+        duplicates = {concept for concept, count in counts.items() if count > 1}
+
+        if duplicates:
+            raise ValueError(f"Duplicate concepts found: {humanize_collection(duplicates)}")
+
+        return value

cognite/neat/_data_model/models/conceptual/_property.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

@@ -32,15 +32,50 @@ from cognite.neat._data_model.models.dms._data_types import (
 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
 
+from ._data_model import DataModelRequest, DataModelResponse
+from ._references import (
+    ContainerDirectReference,
+    ContainerReference,
+    NodeReference,
+    ViewDirectReference,
+    ViewReference,
+)
+from ._view_property import (
+    ConnectionPropertyDefinition,
+    ConstraintOrIndexState,
+    MultiEdgeProperty,
+    MultiReverseDirectRelationPropertyRequest,
+    MultiReverseDirectRelationPropertyResponse,
+    SingleEdgeProperty,
+    SingleReverseDirectRelationPropertyRequest,
+    SingleReverseDirectRelationPropertyResponse,
+    ViewCorePropertyRequest,
+    ViewCorePropertyResponse,
+    ViewPropertyDefinition,
+    ViewRequestProperty,
+    ViewResponseProperty,
+)
+from ._views import (
+    View,
+    ViewRequest,
+    ViewResponse,
+)
+
 __all__ = [
     "BooleanProperty",
     "BtreeIndex",
+    "ConnectionPropertyDefinition",
     "Constraint",
     "ConstraintDefinition",
+    "ConstraintOrIndexState",
     "Container",
+    "ContainerDirectReference",
     "ContainerPropertyDefinition",
+    "ContainerReference",
     "ContainerRequest",
     "ContainerResponse",
+    "DataModelRequest",
+    "DataModelResponse",
     "DataType",
     "DateProperty",
     "DirectNodeRelation",
@@ -54,16 +89,38 @@ __all__ = [
     "InvertedIndex",
     "JSONProperty",
     "ListablePropertyTypeDefinition",
+    "MultiEdgeProperty",
+    "MultiReverseDirectRelationPropertyRequest",
+    "MultiReverseDirectRelationPropertyResponse",
+    "NodeReference",
     "PropertyTypeDefinition",
     "RequiresConstraintDefinition",
     "Resource",
     "SequenceCDFExternalIdReference",
+    "SequenceCDFExternalIdReference",
+    "SingleEdgeProperty",
+    "SingleReverseDirectRelationPropertyRequest",
+    "SingleReverseDirectRelationPropertyResponse",
     "Space",
     "SpaceRequest",
     "SpaceResponse",
     "TextProperty",
+    "TextProperty",
+    "TimeseriesCDFExternalIdReference",
     "TimeseriesCDFExternalIdReference",
     "TimestampProperty",
+    "TimestampProperty",
+    "UniquenessConstraintDefinition",
     "UniquenessConstraintDefinition",
+    "View",
+    "ViewCorePropertyRequest",
+    "ViewCorePropertyResponse",
+    "ViewDirectReference",
+    "ViewPropertyDefinition",
+    "ViewReference",
+    "ViewRequest",
+    "ViewRequestProperty",
+    "ViewResponse",
+    "ViewResponseProperty",
     "WriteableResource",
 ]

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

@@ -3,6 +3,7 @@ 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}$"
+DM_VERSION_PATTERN = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 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(

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

@@ -18,6 +18,7 @@ from ._constants import (
 from ._constraints import Constraint
 from ._data_types import DataType
 from ._indexes import Index
+from ._references import ContainerReference
 
 KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
 
@@ -132,6 +133,12 @@ class Container(Resource, ABC):
             )
         return val
 
+    def as_reference(self) -> ContainerReference:
+        return ContainerReference(
+            space=self.space,
+            externalId=self.external_id,
+        )
+
 
 class ContainerRequest(Container): ...
 

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

@@ -0,0 +1,71 @@
+from abc import ABC
+
+from pydantic import Field
+
+from ._base import Resource, WriteableResource
+from ._constants import (
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
+from ._references import ViewReference
+
+
+class DataModel(Resource, ABC):
+    """Cognite Data Model resource.
+
+    Data models group and structure views into reusable collections.
+    A data model contains a set of views where the node types can
+    refer to each other with direct relations and edges.
+    """
+
+    space: str = Field(
+        description="The workspace for the data model, 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 data model.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the data model.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+    name: str | None = Field(
+        default=None,
+        description="Human readable name for the data model.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the data model.",
+        max_length=1024,
+    )
+    # The API supports View here, but in Neat we will only use ViewReference
+    views: list[ViewReference] | None = Field(
+        description="List of views included in this data model.",
+        default=None,
+    )
+
+
+class DataModelRequest(DataModel): ...
+
+
+class DataModelResponse(DataModel, WriteableResource[DataModelRequest]):
+    created_time: int = Field(
+        description="When the data model 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 data model 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="Is this a global data model.")
+
+    def as_request(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True))

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

@@ -3,10 +3,19 @@ from typing import Literal
 from pydantic import Field
 
 from ._base import BaseModelObject
-from ._constants import DM_EXTERNAL_ID_PATTERN, SPACE_FORMAT_PATTERN
+from ._constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    INSTANCE_ID_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
 
 
-class ContainerReference(BaseModelObject):
+class ReferenceObject(BaseModelObject, frozen=True): ...
+
+
+class ContainerReference(ReferenceObject):
     type: Literal["container"] = "container"
     space: str = Field(
         description="Id of the space hosting (containing) the container.",
@@ -20,3 +29,63 @@ class ContainerReference(BaseModelObject):
         max_length=255,
         pattern=DM_EXTERNAL_ID_PATTERN,
     )
+
+
+class ViewReference(BaseModelObject):
+    type: Literal["view"] = "view"
+    space: str = Field(
+        description="Id of the space that the view belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the view.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the view.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+
+
+class NodeReference(BaseModelObject):
+    space: str = Field(
+        description="Id of the space hosting (containing) the node.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the node.",
+        min_length=1,
+        max_length=255,
+        pattern=INSTANCE_ID_PATTERN,
+    )
+
+
+class ContainerDirectReference(BaseModelObject):
+    source: ContainerReference = Field(
+        description="Reference to the container from where this relation is inherited.",
+    )
+    identifier: str = Field(
+        description="Identifier of the relation in the source container.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )
+
+
+class ViewDirectReference(BaseModelObject):
+    source: ViewReference = Field(
+        description="Reference to the view from where this relation is inherited.",
+    )
+    identifier: str = Field(
+        description="Identifier of the relation in the source view.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )

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

@@ -0,0 +1,198 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, Json
+
+from ._base import BaseModelObject, Resource, WriteableResource
+from ._constants import CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN
+from ._data_types import DataType
+from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
+
+
+class ViewPropertyDefinition(Resource, ABC):
+    connection_type: str
+
+
+class ViewCoreProperty(ViewPropertyDefinition, ABC):
+    # Core properties do not have connection type in the API, but we add it here such that
+    # we can use it as a discriminator in unions. The exclude=True ensures that it is not
+    # sent to the API.
+    connection_type: Literal["primary_property"] = Field(default="primary_property", exclude=True)
+    name: str | None = Field(
+        default=None,
+        description="Readable property name.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property..",
+        max_length=1024,
+    )
+    container: ContainerReference = Field(
+        description="Reference to the container where this property is defined.",
+    )
+    container_property_identifier: str = Field(
+        description="Identifier of the property in the container.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )
+    source: ViewReference | None = Field(
+        default=None,
+        description="Indicates on what type a referenced direct relation is expected to be. "
+        "Only applicable for direct relation properties.",
+    )
+
+
+class ViewCorePropertyRequest(ViewCoreProperty): ...
+
+
+class ConstraintOrIndexState(BaseModelObject):
+    nullability: Literal["current", "pending", "failed"] | None = Field(
+        description="""For properties that have isNullable set to false, this field describes the validity of the
+not-null constraint. It is not specified for nullable properties.
+
+Possible values are:
+
+"failed": The property contains null values, violating the constraint. This can occur if a property with
+          existing nulls was made non-nullable. New null values will still be rejected.
+"current": The constraint is satisfied; all values in the property are not null.
+"pending": The constraint validity has not yet been computed.
+        """
+    )
+
+
+class ViewCorePropertyResponse(ViewCoreProperty, WriteableResource[ViewCorePropertyRequest]):
+    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, Json] | None = Field(
+        default=None,
+        description="Default value to use when you do not specify a value for the property.",
+    )
+    constraint_state: ConstraintOrIndexState = Field(
+        description="Describes the validity of constraints defined on this property"
+    )
+    type: DataType = Field(description="The type of data you can store in this property.")
+
+    def as_request(self) -> ViewCorePropertyRequest:
+        return ViewCorePropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class ConnectionPropertyDefinition(ViewPropertyDefinition, ABC):
+    name: str | None = Field(
+        default=None,
+        description="Readable property name.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property..",
+        max_length=1024,
+    )
+
+
+class EdgeProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference = Field(
+        description="The target node(s) of this connection can be read through the view specified in 'source'."
+    )
+    type: NodeReference = Field(
+        description="Reference to the node pointed to by the direct relation. The reference consists of a "
+        "space and an external-id."
+    )
+    edge_source: ViewReference | None = Field(
+        None, description="The edge(s) of this connection can be read through the view specified in 'edgeSource'."
+    )
+    direction: Literal["outwards", "inwards"] = Field(
+        "outwards", description="The direction of the edge(s) of this connection."
+    )
+
+
+class SingleEdgeProperty(EdgeProperty):
+    connection_type: Literal["single_edge_connection"] = "single_edge_connection"
+
+
+class MultiEdgeProperty(EdgeProperty):
+    connection_type: Literal["multi_edge_connection"] = "multi_edge_connection"
+
+
+class ReverseDirectRelationProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference = Field(
+        description="The node(s) containing the direct relation property can be read "
+        "through the view specified in 'source'."
+    )
+
+
+class SingleReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    # The API support through as either ViewDirectReference or ContainerDirectReference. However, in Neat
+    # we only use ContainerDirectReference. This is for simplicity and it improves performance as the server
+    # does not have to resolve the view to a container first.
+    through: ContainerDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+
+class SingleReverseDirectRelationPropertyResponse(
+    ReverseDirectRelationProperty, WriteableResource[SingleReverseDirectRelationPropertyRequest]
+):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    through: ContainerDirectReference | ViewDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+    def as_request(self) -> SingleReverseDirectRelationPropertyRequest:
+        if isinstance(self.through, ViewDirectReference):
+            raise TypeError("Cannot convert to request when 'through' is a ViewDirectReference.")
+        return SingleReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class MultiReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    # The API support through as either ViewDirectReference or ContainerDirectReference. However, in Neat
+    # we only use ContainerDirectReference. This is for simplicity and it improves performance as the server
+    # does not have to resolve the view to a container first.
+    through: ContainerDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+
+class MultiReverseDirectRelationPropertyResponse(
+    ReverseDirectRelationProperty, WriteableResource[MultiReverseDirectRelationPropertyRequest]
+):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    through: ContainerDirectReference | ViewDirectReference = Field(
+        description="The view of the node containing the direct relation property."
+    )
+
+    def as_request(self) -> MultiReverseDirectRelationPropertyRequest:
+        if isinstance(self.through, ViewDirectReference):
+            raise TypeError("Cannot convert to request when 'through' is a ViewDirectReference.")
+        return MultiReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+ViewRequestProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyRequest
+    | MultiReverseDirectRelationPropertyRequest
+    | ViewCorePropertyRequest,
+    Field(discriminator="connection_type"),
+]
+ViewResponseProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyResponse
+    | MultiReverseDirectRelationPropertyResponse
+    | ViewCorePropertyResponse,
+    Field(discriminator="connection_type"),
+]

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

@@ -0,0 +1,161 @@
+import re
+from abc import ABC
+from typing import Literal, TypeVar
+
+from pydantic import Field, Json, field_validator, model_validator
+
+from cognite.neat._utils.text import humanize_collection
+
+from ._base import Resource, WriteableResource
+from ._constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS,
+    FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER,
+    SPACE_FORMAT_PATTERN,
+)
+from ._references import ContainerReference, ViewReference
+from ._view_property import (
+    ViewRequestProperty,
+    ViewResponseProperty,
+)
+
+KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
+
+
+class View(Resource, ABC):
+    space: str = Field(
+        description="Id of the space that the view belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the view.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the view.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+    name: str | None = Field(
+        default=None,
+        description="name for the view.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the view.",
+        max_length=1024,
+    )
+    filter: dict[str, Json] | None = Field(
+        default=None,
+        description="A filter Domain Specific Language (DSL) used to create advanced filter queries.",
+    )
+    implements: list[ViewReference] | None = Field(
+        default=None,
+        description="References to the views from where this view will inherit properties.",
+    )
+
+    @model_validator(mode="before")
+    def set_connection_type_on_primary_properties(cls, data: dict) -> dict:
+        if "properties" not in data:
+            return data
+        properties = data["properties"]
+        if not isinstance(properties, dict):
+            return data
+        # We assume all properties without connectionType are core properties.
+        # The reason we set connectionType it easy for pydantic to discriminate the union.
+        # This also leads to better error messages, as if there is a union and pydantic do not know which
+        # type to pick it will give errors from all type in the union.
+        for prop in properties.values():
+            if isinstance(prop, dict) and "connectionType" not in prop:
+                prop["connectionType"] = "primary_property"
+        return data
+
+    @field_validator("external_id", mode="after")
+    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}' is a reserved view External ID. Reserved External IDs are: "
+                f"{humanize_collection(FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS)}"
+            )
+        return val
+
+
+class ViewRequest(View):
+    properties: dict[str, ViewRequestProperty] = Field(
+        description="View with included properties and expected edges, indexed by a unique space-local identifier."
+    )
+
+    @field_validator("properties", mode="after")
+    def validate_properties_identifier(cls, val: dict[str, ViewRequestProperty]) -> dict[str, ViewRequestProperty]:
+        """Validate properties Identifier"""
+        return _validate_properties_keys(val)
+
+
+class ViewResponse(View, WriteableResource[ViewRequest]):
+    properties: dict[str, ViewResponseProperty] = Field(
+        description="List of properties and connections included in this view."
+    )
+
+    created_time: int = Field(
+        description="When the view 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 view was last updated. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    writable: bool = Field(
+        description="oes the view support write operations, i.e. is it writable? "
+        "You can write to a view if the view maps all non-nullable properties."
+    )
+    queryable: bool = Field(
+        description="Does the view support queries, i.e. is it queryable? You can query a view if "
+        "it either has a filter or at least one property mapped to a container."
+    )
+    used_for: Literal["node", "edge", "all"] = Field(description="Should this operation apply to nodes, edges or both.")
+    is_global: bool = Field(description="Is this a global view.")
+    mapped_containers: list[ContainerReference] = Field(
+        description="List of containers with properties mapped by this view."
+    )
+
+    @field_validator("properties", mode="after")
+    def validate_properties_identifier(cls, val: dict[str, ViewResponseProperty]) -> dict[str, ViewResponseProperty]:
+        """Validate properties Identifier"""
+        return _validate_properties_keys(val)
+
+    def as_request(self) -> ViewRequest:
+        dumped = self.model_dump(by_alias=True, exclude={"properties"})
+        dumped["properties"] = {
+            key: value.as_request().model_dump(by_alias=True)
+            if isinstance(value, WriteableResource)
+            else value.model_dump(by_alias=True)
+            for key, value in self.properties.items()
+        }
+        return ViewRequest.model_validate(dumped)
+
+
+T_Property = TypeVar("T_Property")
+
+
+def _validate_properties_keys(properties: dict[str, T_Property]) -> dict[str, T_Property]:
+    """Validate keys of a properties dictionary."""
+    errors: list[str] = []
+    for key in properties:
+        if not KEY_PATTERN.match(key):
+            errors.append(f"Property '{key}' does not match the required pattern: {KEY_PATTERN.pattern}")
+        if key in FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER:
+            errors.append(
+                f"'{key}' is a reserved property identifier. Reserved identifiers are: "
+                f"{humanize_collection(FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER)}"
+            )
+    if errors:
+        raise ValueError("; ".join(errors))
+    return properties

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

@@ -4,6 +4,9 @@ from typing import Any
 from pydantic import BaseModel, Field, field_validator, model_serializer
 
 from ._constants import (
+    PREFIX_PATTERN,
+    SUFFIX_PATTERN,
+    VERSION_PATTERN,
     Undefined,
     Unknown,
     _UndefinedType,
@@ -15,10 +18,8 @@ from ._constants import (
 class Entity(BaseModel, extra="ignore", populate_by_name=True):
     """Entity is a concept, class, property, datatype in semantics sense."""
 
-    prefix: str | _UndefinedType = Field(
-        default=Undefined, pattern=r"^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$", min_length=1, max_length=43
-    )
-    suffix: str = Field(min_length=1, max_length=255, pattern=r"^[a-zA-Z0-9._~?@!$&'*+,;=%-]+$")
+    prefix: str | _UndefinedType = Field(default=Undefined, pattern=PREFIX_PATTERN, min_length=1, max_length=43)
+    suffix: str = Field(min_length=1, max_length=255, pattern=SUFFIX_PATTERN)
 
     @model_serializer(when_used="unless-none", return_type=str)
     def as_str(self) -> str:
@@ -88,7 +89,7 @@ class Entity(BaseModel, extra="ignore", populate_by_name=True):
 
 
 class ConceptEntity(Entity):
-    version: str | None = None
+    version: str | None = Field(default=None, pattern=VERSION_PATTERN, max_length=43)
 
 
 class UnknownEntity(ConceptEntity):

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

@@ -15,3 +15,8 @@ class _UnknownType(BaseModel):
 # This is a trick to make Undefined and Unknown singletons
 Undefined = _UndefinedType()
 Unknown = _UnknownType()
+
+
+PREFIX_PATTERN = r"^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
+SUFFIX_PATTERN = r"^[a-zA-Z0-9._~?@!$&'*+,;=%-]+$"
+VERSION_PATTERN = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"

cognite/neat/_version.py

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

cognite/neat/v0/core/_data_model/models/data_types.py

@@ -302,7 +302,7 @@ class DateTime(DataType):
     python = datetime
     dms = dms.Timestamp
     graphql = "Timestamp"
-    xsd = "dateTimeStamp"
+    xsd = "dateTime"
     sql = "TIMESTAMP"
 
     name: typing.Literal["dateTime"] = "dateTime"

cognite/neat/v0/core/_instances/extractors/_dict.py

@@ -43,9 +43,12 @@ class DictExtractor(BaseExtractor):
         self, key: str, value: Any, unpack_json: bool
     ) -> Iterable[tuple[str, Literal | URIRef]]:
         if key in self.uri_ref_keys and not isinstance(value, dict | list):
+            # exist if key is meant to form a URIRef
             yield key, URIRef(self.namespace[urllib.parse.quote(value)])
-        if isinstance(value, str | float | bool | int):
+        elif isinstance(value, float | bool | int):
             yield key, Literal(value)
+        elif isinstance(value, str):
+            yield key, Literal(string_to_ideal_type(value)) if self.str_to_ideal_type else Literal(value)
         elif isinstance(value, dict) and unpack_json:
             yield from self._unpack_json(value)
         elif isinstance(value, dict):

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

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

@@ -1,6 +1,6 @@
 cognite/neat/__init__.py,sha256=Lo4DbjDOwnhCYUoAgPp5RG1fDdF7OlnomalTe7n1ydw,211
 cognite/neat/_issues.py,sha256=uv0fkkWwTKqNmTmHqyoBB3L6yMCh42EZpEkLGmIJYOY,812
-cognite/neat/_version.py,sha256=AcC3bBw58APEu-16ayi6h9wHbjFkLKdwAnhBj7XMeqk,47
+cognite/neat/_version.py,sha256=EIGI3787UrfBLzGRh7i7dj6FiXl8fYEyp70inEeAqk8,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
@@ -8,19 +8,24 @@ cognite/neat/_data_model/_identifiers.py,sha256=a0LcQ_h0NffxSKTCrzCDpYkrlaUTk-D_
 cognite/neat/_data_model/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/_concept.py,sha256=0Pk4W2TJ_Y0Z7oPHpzely1kPXrAkmkyqw6a0n3il6LY,2248
 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/conceptual/_property.py,sha256=CpF37vJYBTLT4DH4ZOu2U-JyWtkb_27V8fw52qiaE_k,4007
+cognite/neat/_data_model/models/dms/__init__.py,sha256=WDF6VOPdVbH5QX1Z_k5fLqxY1Joqy94IEEpPs69UnrQ,3477
 cognite/neat/_data_model/models/dms/_base.py,sha256=R8SP3Zi9daTBqewYKGjuNEkrWc-j91f-6t34CN-9YJ0,719
-cognite/neat/_data_model/models/dms/_constants.py,sha256=tLyle1N_ekNBhANleG7GvZB85P4uGaoWl2mqeR-vfmY,1272
+cognite/neat/_data_model/models/dms/_constants.py,sha256=wBkLjAPwufPc2naxOfPA1XC0CM2RbDbo6Dpiv9dPrew,1344
 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/_container.py,sha256=SgrMCRo04A1gqayJsCia6oMhYT7q3NaeMBZMOQNI-lA,5967
+cognite/neat/_data_model/models/dms/_data_model.py,sha256=vm_MPKdNAh9Ig4J4yz8gHv-qam_1rnH4SGwWXzPFPtw,2316
 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/_references.py,sha256=OLqp3EFMJDOl4Zaw2IdtM2vPWeDZf6VMYPgjNX6R0Jc,2532
 cognite/neat/_data_model/models/dms/_space.py,sha256=-1LkRmQaAdIj2EYDcVv5Mcejl5uswgAEVv7DztpIUk4,1680
+cognite/neat/_data_model/models/dms/_view_property.py,sha256=wiRxb5qtzGnBooBUzN7xtwMBZiZ9aRFcN5ML4lCTXdQ,8331
+cognite/neat/_data_model/models/dms/_views.py,sha256=mpIKOgMs5WkUZ8fupcHGOrcJtDH9o4f0fhuB3Pua5OE,6435
 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/_base.py,sha256=PaNrD29iwxuqTpRWbmESMTxRhhKXmRyDF_cLZEC69dg,3927
+cognite/neat/_data_model/models/entities/_constants.py,sha256=EK9Bus8UgFgxK5cVFMTAqWSl6aWkDe7d59hpUmlHlBs,517
 cognite/neat/_data_model/models/entities/_data_types.py,sha256=DfdEWGek7gODro-_0SiiInhPGwul4zn-ASACQfn8HUY,2838
 cognite/neat/_data_model/models/entities/_identifiers.py,sha256=uBiK4ot3V0b_LGXuJ7bfha6AEcFI3p2letr1z2iSvig,1923
 cognite/neat/_data_model/models/entities/_parser.py,sha256=ZLGw0cFV-B7JuaAUJ65Jbjf6o-vidz9_BZvilS6lAZw,6455
@@ -85,7 +90,7 @@ cognite/neat/v0/core/_data_model/models/_base_unverified.py,sha256=1Wfbp-tJaEF6h
 cognite/neat/v0/core/_data_model/models/_base_verified.py,sha256=9EhRUEJ7ma-MnEFvXeQg6ew_gAcfLEapkckPX6mrlYQ,15142
 cognite/neat/v0/core/_data_model/models/_import_contexts.py,sha256=_agCsWvq_ky_Np83UO1qRSlOodlBSLDFp29rB5Ty5hw,3439
 cognite/neat/v0/core/_data_model/models/_types.py,sha256=A7lKYqGlEGRvXpsCdx-XGcFony0VeNCk9tRxeQpF6Po,5503
-cognite/neat/v0/core/_data_model/models/data_types.py,sha256=Px1PeZmq23iaVWhOgJNA5VZAFrAym6dipbd3Fw4SnFU,10547
+cognite/neat/v0/core/_data_model/models/data_types.py,sha256=qZIlRWaOGqfq97iRAP0lVNNXUAKxwy0zJoQex4uoqcA,10542
 cognite/neat/v0/core/_data_model/models/conceptual/__init__.py,sha256=9A6myEV8s0-LqdXejaljqPj8S0pIpUL75rNdRDZzyR8,585
 cognite/neat/v0/core/_data_model/models/conceptual/_unverified.py,sha256=UvqjGxVQsf_cNCYf726TXgnPplUy3iBuI-nUp0TclD0,6539
 cognite/neat/v0/core/_data_model/models/conceptual/_validation.py,sha256=oaXRe1RfwsCQ_D5-IdXJf6yZ4Eug_PLu-bDklADYGV4,13895
@@ -123,7 +128,7 @@ cognite/neat/v0/core/_instances/examples/__init__.py,sha256=yAjHVY3b5jOjmbW-iLbh
 cognite/neat/v0/core/_instances/examples/skos-capturing-sheet-wind-topics.xlsx,sha256=CV_yK5ZSbYS_ktfIZUPD8Sevs47zpswLXQUDFkGE4Gw,45798
 cognite/neat/v0/core/_instances/extractors/__init__.py,sha256=x8nnTw8io_9INZuiHzWe__yB6G9GUdjEeaWGAx_MzHk,2212
 cognite/neat/v0/core/_instances/extractors/_base.py,sha256=dz0xAHDA0EUofRRxja9IKWoAXl3_vY4mnxO5We0LLDw,1974
-cognite/neat/v0/core/_instances/extractors/_dict.py,sha256=7Qa0oLdKvUTBSshUK3g4T6n_6UE3ncaGBUXXzwveS_Q,4337
+cognite/neat/v0/core/_instances/extractors/_dict.py,sha256=wsHDEa-VcoLxayWm5BONw3LyeT-jF8n4sBSInUXRZ0k,4529
 cognite/neat/v0/core/_instances/extractors/_dms.py,sha256=DFYSNd3wU-MCCDddojH6KX1wsx1gLz9fv34-WfnjwBE,13858
 cognite/neat/v0/core/_instances/extractors/_dms_graph.py,sha256=VS8--8BH8cy9f1JUek_g3vIC4c6VkzBXhvPKqHydKjc,10228
 cognite/neat/v0/core/_instances/extractors/_mock_graph_generator.py,sha256=3WxMWXXxQdth7Na6XMhNeAfqUKxK-8S8CEKAEPKBMDk,15954
@@ -223,7 +228,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.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,,
+cognite_neat-0.123.40.dist-info/METADATA,sha256=922IsoPiMWLcfFWeR64XxhshmVXVHh8iI8HSqODPWrY,9148
+cognite_neat-0.123.40.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.40.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.40.dist-info/RECORD,,