cognite-neat 0.126.0__py3-none-any.whl → 0.126.1__py3-none-any.whl

cognite/neat/_data_model/importers/_table_importer/importer.py

@@ -1,21 +1,25 @@
 from collections.abc import Mapping
+from pathlib import Path
 from typing import ClassVar, cast
 
+import yaml
+from openpyxl import load_workbook
+from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import ValidationError
 
 from cognite.neat._data_model.importers._base import DMSImporter
 from cognite.neat._data_model.models.dms import (
     RequestSchema,
 )
-from cognite.neat._exceptions import DataModelImportError
+from cognite.neat._exceptions import DataModelImportException
 from cognite.neat._issues import ModelSyntaxError
 from cognite.neat._utils.text import humanize_collection
-from cognite.neat._utils.useful_types import DataModelTableType
+from cognite.neat._utils.useful_types import CellValueType, DataModelTableType
 from cognite.neat._utils.validation import as_json_path, humanize_validation_error
 
 from .data_classes import MetadataValue, TableDMS
 from .reader import DMSTableReader
-from .source import TableSource
+from .source import SpreadsheetReadContext, TableSource
 
 
 class DMSTableImporter(DMSImporter):
@@ -32,6 +36,7 @@ class DMSTableImporter(DMSImporter):
     REQUIRED_SHEET_MESSAGES: ClassVar[Mapping[str, str]] = {
         f"Missing required column: {sheet!r}": f"Missing required sheet: {sheet!r}" for sheet in REQUIRED_SHEETS
     }
+    MetadataSheet = cast(str, TableDMS.model_fields["metadata"].validation_alias)
 
     def __init__(self, tables: DataModelTableType, source: TableSource | None = None) -> None:
         self._table = tables
@@ -44,13 +49,40 @@ class DMSTableImporter(DMSImporter):
         reader = DMSTableReader(space, version, self._source)
         return reader.read_tables(tables)
 
+    @classmethod
+    def from_yaml(cls, yaml_file: Path) -> "DMSTableImporter":
+        """Create a DMSTableImporter from a YAML file."""
+        source = cls._display_name(yaml_file)
+        return cls(yaml.safe_load(yaml_file.read_text()), TableSource(source.as_posix()))
+
+    @classmethod
+    def from_excel(cls, excel_file: Path) -> "DMSTableImporter":
+        """Create a DMSTableImporter from an Excel file."""
+        tables: DataModelTableType = {}
+        source = TableSource(cls._display_name(excel_file).as_posix())
+        workbook = load_workbook(excel_file, read_only=True, data_only=True, rich_text=False)
+        try:
+            for column_id, column_info in TableDMS.model_fields.items():
+                sheet_name = cast(str, column_info.validation_alias)
+                if sheet_name not in workbook.sheetnames:
+                    continue
+                required_columns = TableDMS.get_sheet_columns(column_id, column_info, column_type="required")
+                sheet = workbook[sheet_name]
+                context = SpreadsheetReadContext()
+                table_rows = cls._read_rows(sheet, required_columns, context)
+                tables[sheet_name] = table_rows
+                source.table_read[sheet_name] = context
+            return cls(tables, source)
+        finally:
+            workbook.close()
+
     def _read_tables(self) -> TableDMS:
         try:
             # Check tables, columns, data type and entity syntax.
             table = TableDMS.model_validate(self._table)
         except ValidationError as e:
             errors = self._create_error_messages(e)
-            raise DataModelImportError(errors) from None
+            raise DataModelImportException(errors) from None
         return table
 
     def _create_error_messages(self, error: ValidationError) -> list[ModelSyntaxError]:
@@ -99,5 +131,42 @@ class DMSTableImporter(DMSImporter):
         if missing:
             error = ModelSyntaxError(message=f"In Metadata missing required values: {humanize_collection(missing)}")
             # If space or version is missing, we cannot continue parsing the model as these are used as defaults.
-            raise DataModelImportError([error]) from None
+            raise DataModelImportException([error]) from None
         return str(default_space), str(default_version)
+
+    @classmethod
+    def _display_name(cls, filepath: Path) -> Path:
+        """Get a display-friendly version of the file path."""
+        cwd = Path.cwd()
+        source = filepath
+        if filepath.is_relative_to(cwd):
+            source = filepath.relative_to(cwd)
+        return source
+
+    @classmethod
+    def _read_rows(
+        cls, sheet: Worksheet, required_columns: list[str], context: SpreadsheetReadContext
+    ) -> list[dict[str, CellValueType]]:
+        table_rows: list[dict[str, CellValueType]] = []
+        # Metadata sheet is just a key-value pair of the first two columns.
+        # For other sheets, we need to find the column header row first.
+        columns: list[str] = [] if sheet.title != cls.MetadataSheet else required_columns
+        for row_no, row in enumerate(sheet.iter_rows(values_only=True)):
+            if columns:
+                # We have found the column header row, read the data rows.
+                if all(cell is None for cell in row):
+                    context.empty_rows.append(row_no)
+                else:
+                    record = dict(zip(columns, row, strict=False))
+                    # MyPy complains as it thinks DataTableFormula | ArrayFormula could be cell values,
+                    # but as we used values_only=True, this is not the case.
+                    table_rows.append(record)  # type: ignore[arg-type]
+            else:
+                # Look for the column header row.
+                row_values = [str(cell) for cell in row]
+                if set(row_values).intersection(required_columns):
+                    columns = row_values
+                    context.header_row = row_no
+                else:
+                    context.skipped_rows.append(row_no)
+        return table_rows

cognite/neat/_data_model/importers/_table_importer/reader.py

@@ -22,7 +22,7 @@ from cognite.neat._data_model.models.dms import (
     ViewRequestPropertyAdapter,
 )
 from cognite.neat._data_model.models.entities import ParsedEntity, parse_entity
-from cognite.neat._exceptions import DataModelImportError
+from cognite.neat._exceptions import DataModelImportException
 from cognite.neat._issues import ModelSyntaxError
 from cognite.neat._utils.text import humanize_collection
 from cognite.neat._utils.validation import humanize_validation_error
@@ -151,6 +151,7 @@ class DMSTableReader:
 
     class ContainerColumns:
         container = cast(str, DMSContainer.model_fields["container"].validation_alias)
+        constraint = cast(str, DMSContainer.model_fields["constraint"].validation_alias)
 
     class ViewColumns:
         view = cast(str, DMSView.model_fields["view"].validation_alias)
@@ -173,7 +174,7 @@ class DMSTableReader:
         data_model = self.read_data_model(tables, valid_view_entities)
 
         if self.errors:
-            raise DataModelImportError(self.errors) from None
+            raise DataModelImportException(self.errors) from None
         return RequestSchema(
             dataModel=data_model, views=views, containers=containers, spaces=[space_request], nodeTypes=node_types
         )
@@ -182,7 +183,7 @@ class DMSTableReader:
         space_request = self._validate_obj(SpaceRequest, {"space": space}, (self.Sheets.metadata,), field_name="value")
         if space_request is None:
             # If space is invalid, we stop parsing to avoid raising an error for every place the space is used.
-            raise DataModelImportError(self.errors) from None
+            raise DataModelImportException(self.errors) from None
         return space_request
 
     def read_nodes(self, nodes: list[DMSNode]) -> list[NodeReference]:
@@ -427,7 +428,7 @@ class DMSTableReader:
             return
         loc = (self.Sheets.properties, row_no, self.PropertyColumns.constraint)
         for constraint in prop.constraint:
-            data = self.read_constraint(constraint, prop.container_property)
+            data = self.read_property_constraint(constraint, prop.container_property)
             created = self._validate_adapter(ConstraintAdapter, data, loc)
             if created is None:
                 continue
@@ -443,7 +444,7 @@ class DMSTableReader:
             )
 
     @staticmethod
-    def read_constraint(constraint: ParsedEntity, prop_id: str) -> dict[str, Any]:
+    def read_property_constraint(constraint: ParsedEntity, prop_id: str) -> dict[str, Any]:
         return {"constraintType": constraint.prefix, "properties": [prop_id], **constraint.properties}
 
     def read_view_property(self, prop: DMSProperty, loc: tuple[str | int, ...]) -> dict[str, Any]:
@@ -574,6 +575,22 @@ class DMSTableReader:
         containers_requests: list[ContainerRequest] = []
         rows_by_seen: dict[ParsedEntity, list[int]] = defaultdict(list)
         for row_no, container in enumerate(containers):
+            property_constraints = properties.constraints.get(container.container, {})
+            require_constraints = self.read_container_constraints(container, row_no)
+            if conflict := set(property_constraints.keys()).intersection(set(require_constraints.keys())):
+                conflict_str = humanize_collection(conflict)
+                location_str = self.source.location((self.Sheets.containers, row_no, self.ContainerColumns.constraint))
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {location_str} the container '{container.container!s}' has constraints defined "
+                            f"with the same identifier(s) as the uniqueness constraint defined in the "
+                            f"{self.Sheets.properties} sheet. Ensure that the identifiers are unique. "
+                            f"Conflicting identifiers: {conflict_str}. "
+                        )
+                    )
+                )
+            constraints = {**property_constraints, **require_constraints}
             container_request = self._validate_obj(
                 ContainerRequest,
                 dict(
@@ -583,7 +600,7 @@ class DMSTableReader:
                     description=container.description,
                     properties=properties.container[container.container],
                     indexes=properties.indices.get(container.container),
-                    constraints=properties.constraints.get(container.container),
+                    constraints=constraints or None,
                 ),
                 (self.Sheets.containers, row_no),
             )
@@ -608,6 +625,45 @@ class DMSTableReader:
                 )
         return containers_requests
 
+    def read_container_constraints(self, container: DMSContainer, row_no: int) -> dict[str, Constraint]:
+        constraints: dict[str, Constraint] = {}
+        if not container.constraint:
+            return constraints
+        for entity in container.constraint:
+            loc = self.Sheets.containers, row_no, self.ContainerColumns.constraint
+            if entity.prefix != "requires":
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location(loc)} the constraint '{entity.suffix}' on container "
+                            f"'{container.container!s}' has an invalid type '{entity.prefix}'. Only 'requires' "
+                            f"constraints are supported at the container level."
+                        )
+                    )
+                )
+                continue
+
+            if "require" not in entity.properties:
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location(loc)} the constraint '{entity.suffix}' on container "
+                            f"'{container.container!s}' is missing the "
+                            f"'require' property which is required for container level constraints."
+                        )
+                    )
+                )
+                continue
+            data = {
+                "constraintType": entity.prefix,
+                "require": self._create_container_ref_unparsed(entity.properties["require"], loc),
+            }
+            created = self._validate_adapter(ConstraintAdapter, data, loc)
+            if created is None:
+                continue
+            constraints[entity.suffix] = created
+        return constraints
+
     def read_views(
         self,
         views: list[DMSView],
@@ -674,7 +730,7 @@ class DMSTableReader:
         model = self._validate_obj(DataModelRequest, data, (self.Sheets.metadata,), field_name="value")
         if model is None:
             # This is the last step, so we can raise the error here.
-            raise DataModelImportError(self.errors) from None
+            raise DataModelImportException(self.errors) from None
         return model
 
     def _parse_entity(self, entity: str, loc: tuple[str | int, ...]) -> ParsedEntity | None:

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

@@ -1,4 +1,10 @@
-from cognite.neat._data_model.models.dms._base import Resource, WriteableResource
+from cognite.neat._data_model.models.dms._base import (
+    APIResource,
+    BaseModelObject,
+    Resource,
+    T_Resource,
+    WriteableResource,
+)
 from cognite.neat._data_model.models.dms._constraints import (
     Constraint,
     ConstraintAdapter,
@@ -13,6 +19,7 @@ from cognite.neat._data_model.models.dms._container import (
     ContainerResponse,
 )
 from cognite.neat._data_model.models.dms._data_types import (
+    DMS_DATA_TYPES,
     BooleanProperty,
     DataType,
     DataTypeAdapter,
@@ -38,11 +45,13 @@ from cognite.neat._data_model.models.dms._indexes import BtreeIndex, Index, Inde
 from cognite.neat._data_model.models.dms._space import Space, SpaceRequest, SpaceResponse
 
 from ._data_model import DataModelRequest, DataModelResponse
+from ._http import DataModelBody, DataModelResource
 from ._references import (
     ContainerDirectReference,
     ContainerReference,
     DataModelReference,
     NodeReference,
+    SpaceReference,
     ViewDirectReference,
     ViewReference,
 )
@@ -70,6 +79,9 @@ from ._views import (
 )
 
 __all__ = [
+    "DMS_DATA_TYPES",
+    "APIResource",
+    "BaseModelObject",
     "BooleanProperty",
     "BtreeIndex",
     "ConnectionPropertyDefinition",
@@ -83,8 +95,10 @@ __all__ = [
     "ContainerReference",
     "ContainerRequest",
     "ContainerResponse",
+    "DataModelBody",
     "DataModelReference",
     "DataModelRequest",
+    "DataModelResource",
     "DataModelResponse",
     "DataType",
     "DataTypeAdapter",
@@ -118,8 +132,10 @@ __all__ = [
     "SingleReverseDirectRelationPropertyRequest",
     "SingleReverseDirectRelationPropertyResponse",
     "Space",
+    "SpaceReference",
     "SpaceRequest",
     "SpaceResponse",
+    "T_Resource",
     "TextProperty",
     "TextProperty",
     "TimeseriesCDFExternalIdReference",

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

@@ -1,14 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
-from pydantic import BaseModel
-from pydantic.alias_generators import to_camel
-
-
-class BaseModelObject(BaseModel, alias_generator=to_camel, extra="ignore"):
-    """Base class for all object. This includes resources and nested objects."""
-
-    ...
+from cognite.neat._utils.useful_types import BaseModelObject, T_Reference
 
 
 class Resource(BaseModelObject):
@@ -21,7 +14,18 @@ T_Resource = TypeVar("T_Resource", bound=Resource)
 
 
 class WriteableResource(Resource, Generic[T_Resource], ABC):
+    """Base class for all writeable data modeling resources."""
+
     @abstractmethod
     def as_request(self) -> T_Resource:
         """Convert the response model to a request model by removing read-only fields."""
         raise NotImplementedError()
+
+
+class APIResource(Generic[T_Reference], ABC):
+    """Base class for all API data modeling resources."""
+
+    @abstractmethod
+    def as_reference(self) -> T_Reference:
+        """Convert the resource to a reference object (identifier)."""
+        raise NotImplementedError()

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

@@ -1,7 +1,7 @@
 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}$"
+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"})

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

@@ -3,7 +3,8 @@ from typing import Annotated, Literal
 
 from pydantic import Field, TypeAdapter
 
-from ._base import BaseModelObject
+from cognite.neat._utils.useful_types import BaseModelObject
+
 from ._references import ContainerReference
 from ._types import Bool
 

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

@@ -6,8 +6,9 @@ from pydantic import Field, field_validator
 from pydantic_core.core_schema import ValidationInfo
 
 from cognite.neat._utils.text import humanize_collection
+from cognite.neat._utils.useful_types import BaseModelObject
 
-from ._base import BaseModelObject, Resource, WriteableResource
+from ._base import APIResource, Resource, WriteableResource
 from ._constants import (
     CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
     DM_EXTERNAL_ID_PATTERN,
@@ -36,7 +37,7 @@ class ContainerPropertyDefinition(BaseModelObject):
         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_value: str | int | float | bool | dict[str, Any] | None = Field(
         default=None,
         description="Default value to use when you do not specify a value for the property.",
     )
@@ -53,7 +54,7 @@ class ContainerPropertyDefinition(BaseModelObject):
     type: DataType = Field(description="The type of data you can store in this property.")
 
 
-class Container(Resource, ABC):
+class Container(Resource, APIResource[ContainerReference], ABC):
     space: str = Field(
         description="The workspace for the container, a unique identifier for the space.",
         min_length=1,
@@ -82,7 +83,6 @@ class Container(Resource, ABC):
     )
     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,
@@ -136,7 +136,7 @@ class Container(Resource, ABC):
     def as_reference(self) -> ContainerReference:
         return ContainerReference(
             space=self.space,
-            externalId=self.external_id,
+            external_id=self.external_id,
         )
 
 

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

@@ -2,7 +2,7 @@ from abc import ABC
 
 from pydantic import Field
 
-from ._base import Resource, WriteableResource
+from ._base import APIResource, Resource, WriteableResource
 from ._constants import (
     DM_EXTERNAL_ID_PATTERN,
     DM_VERSION_PATTERN,
@@ -11,7 +11,7 @@ from ._constants import (
 from ._references import DataModelReference, ViewReference
 
 
-class DataModel(Resource, ABC):
+class DataModel(Resource, APIResource[DataModelReference], ABC):
     """Cognite Data Model resource.
 
     Data models group and structure views into reusable collections.
@@ -55,7 +55,7 @@ class DataModel(Resource, ABC):
     def as_reference(self) -> DataModelReference:
         return DataModelReference(
             space=self.space,
-            externalId=self.external_id,
+            external_id=self.external_id,
             version=self.version,
         )
 

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

@@ -1,10 +1,13 @@
 import re
 from abc import ABC
+from collections.abc import Mapping
 from typing import Annotated, Literal
 
 from pydantic import Field, TypeAdapter, field_validator
 
-from ._base import BaseModelObject
+from cognite.neat._utils.auxiliary import get_concrete_subclasses
+from cognite.neat._utils.useful_types import BaseModelObject
+
 from ._constants import ENUM_VALUE_IDENTIFIER_PATTERN, FORBIDDEN_ENUM_VALUES, INSTANCE_ID_PATTERN
 from ._references import ContainerReference
 
@@ -181,3 +184,7 @@ DataType = Annotated[
 ]
 
 DataTypeAdapter: TypeAdapter[DataType] = TypeAdapter(DataType)
+
+DMS_DATA_TYPES: Mapping[str, type[PropertyTypeDefinition]] = {
+    cls_.model_fields["type"].default: cls_ for cls_ in get_concrete_subclasses(PropertyTypeDefinition)
+}

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

@@ -0,0 +1,18 @@
+from typing import TypeAlias, TypeVar
+
+from cognite.neat._utils.http_client import ItemBody
+from cognite.neat._utils.useful_types import ReferenceObject
+
+from ._container import ContainerRequest
+from ._data_model import DataModelRequest
+from ._space import SpaceRequest
+from ._views import ViewRequest
+
+DataModelResource: TypeAlias = SpaceRequest | DataModelRequest | ViewRequest | ContainerRequest
+
+T_DataModelResource = TypeVar("T_DataModelResource", bound=DataModelResource)
+
+
+class DataModelBody(ItemBody[ReferenceObject, DataModelResource]):
+    def as_ids(self) -> list[ReferenceObject]:
+        return [item.as_reference() for item in self.items]

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

@@ -3,7 +3,8 @@ from typing import Annotated, Literal
 
 from pydantic import Field, TypeAdapter
 
-from ._base import BaseModelObject
+from cognite.neat._utils.useful_types import BaseModelObject
+
 from ._types import Bool
 
 

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

@@ -2,7 +2,8 @@ from typing import Literal
 
 from pydantic import Field
 
-from ._base import BaseModelObject
+from cognite.neat._utils.useful_types import ReferenceObject
+
 from ._constants import (
     CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
     DM_EXTERNAL_ID_PATTERN,
@@ -12,11 +13,17 @@ from ._constants import (
 )
 
 
-class ReferenceObject(BaseModelObject, frozen=True): ...
+class SpaceReference(ReferenceObject):
+    space: str = Field(
+        description="Id of the space.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
 
 
 class ContainerReference(ReferenceObject):
-    type: Literal["container"] = "container"
+    type: Literal["container"] = Field("container", exclude=True)
     space: str = Field(
         description="Id of the space hosting (containing) the container.",
         min_length=1,
@@ -30,9 +37,12 @@ class ContainerReference(ReferenceObject):
         pattern=DM_EXTERNAL_ID_PATTERN,
     )
 
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
 
 class ViewReference(ReferenceObject):
-    type: Literal["view"] = "view"
+    type: Literal["view"] = Field("view", exclude=True)
     space: str = Field(
         description="Id of the space that the view belongs to.",
         min_length=1,
@@ -51,6 +61,9 @@ class ViewReference(ReferenceObject):
         pattern=DM_VERSION_PATTERN,
     )
 
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(version={self.version})"
+
 
 class DataModelReference(ReferenceObject):
     space: str = Field(

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

@@ -2,13 +2,14 @@ from abc import ABC
 
 from pydantic import Field, field_validator
 
+from cognite.neat._data_model.models.dms._references import SpaceReference
 from cognite.neat.v0.core._utils.text import humanize_collection
 
-from ._base import WriteableResource
+from ._base import APIResource, Resource, WriteableResource
 from ._constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN
 
 
-class Space(WriteableResource["SpaceRequest"], ABC):
+class Space(Resource, APIResource[SpaceReference], ABC):
     space: str = Field(
         description="The Space identifier (id).",
         min_length=1,
@@ -25,11 +26,14 @@ class Space(WriteableResource["SpaceRequest"], ABC):
             raise ValueError(f"{val!r} is a reserved space. Reserved Spaces: {humanize_collection(FORBIDDEN_SPACES)}")
         return val
 
-    def as_request(self) -> "SpaceRequest":
-        return SpaceRequest.model_validate(self.model_dump(by_alias=True))
+    def as_reference(self) -> SpaceReference:
+        return SpaceReference(space=self.space)
+
+
+class SpaceRequest(Space): ...
 
 
-class SpaceResponse(Space):
+class SpaceResponse(Space, WriteableResource[Space]):
     created_time: int = Field(
         description="When the space was created. The number of milliseconds since 00:00:00 Thursday, 1 January 1970, "
         "Coordinated Universal Time (UTC), minus leap seconds."
@@ -40,5 +44,5 @@ class SpaceResponse(Space):
     )
     is_global: bool = Field(description="Whether the space is a global space.")
 
-
-class SpaceRequest(Space): ...
+    def as_request(self) -> "SpaceRequest":
+        return SpaceRequest.model_validate(self.model_dump(by_alias=True))

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

@@ -3,7 +3,9 @@ from typing import Annotated, Literal
 
 from pydantic import Field, Json, TypeAdapter
 
-from ._base import BaseModelObject, Resource, WriteableResource
+from cognite.neat._utils.useful_types import BaseModelObject
+
+from ._base import Resource, WriteableResource
 from ._constants import CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN
 from ._data_types import DataType
 from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
@@ -49,6 +51,7 @@ class ViewCorePropertyRequest(ViewCoreProperty): ...
 
 class ConstraintOrIndexState(BaseModelObject):
     nullability: Literal["current", "pending", "failed"] | None = Field(
+        None,
         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.
 
@@ -58,7 +61,7 @@ Possible values are:
           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.
-        """
+        """,
     )
 
 
@@ -147,7 +150,7 @@ class SingleReverseDirectRelationPropertyResponse(
     ReverseDirectRelationProperty, WriteableResource[SingleReverseDirectRelationPropertyRequest]
 ):
     connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
-    target_list: bool = Field(
+    targets_list: bool = Field(
         description="Whether or not this reverse direct relation targets a list of direct relations.",
     )
 
@@ -159,7 +162,7 @@ class MultiReverseDirectRelationPropertyResponse(
     ReverseDirectRelationProperty, WriteableResource[MultiReverseDirectRelationPropertyRequest]
 ):
     connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
-    target_list: bool = Field(
+    targets_list: bool = Field(
         description="Whether or not this reverse direct relation targets a list of direct relations.",
     )