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

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

@@ -0,0 +1,48 @@
+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}$"
+DM_VERSION_PATTERN = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
+DATA_MODEL_DESCRIPTION_MAX_LENGTH = 1024
+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,42 @@
+from abc import ABC
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, TypeAdapter, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite.neat._utils.useful_types import BaseModelObject
+
+from ._references import ContainerReference
+from ._types import Bool
+
+
+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.")
+
+    @field_serializer("require", mode="plain")
+    @classmethod
+    def serialize_require(cls, require: ContainerReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        output = require.model_dump(**vars(info))
+        output["type"] = "container"
+        return output
+
+
+Constraint = Annotated[
+    UniquenessConstraintDefinition | RequiresConstraintDefinition,
+    Field(discriminator="constraint_type"),
+]
+
+ConstraintAdapter: TypeAdapter[Constraint] = TypeAdapter(Constraint)

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

@@ -0,0 +1,159 @@
+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 cognite.neat._utils.useful_types import BaseModelObject
+
+from ._base import APIResource, 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
+from ._references import ContainerReference
+
+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 | float | 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, APIResource[ContainerReference], 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.",
+    )
+    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
+
+    def as_reference(self) -> ContainerReference:
+        return ContainerReference(
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+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_model.py

@@ -0,0 +1,95 @@
+from abc import ABC
+from typing import Any
+
+from pydantic import Field, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from ._base import APIResource, Resource, WriteableResource
+from ._constants import (
+    DATA_MODEL_DESCRIPTION_MAX_LENGTH,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
+from ._references import DataModelReference, ViewReference
+
+
+class DataModel(Resource, APIResource[DataModelReference], 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=DATA_MODEL_DESCRIPTION_MAX_LENGTH,
+    )
+    # 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,
+    )
+
+    def as_reference(self) -> DataModelReference:
+        return DataModelReference(
+            space=self.space,
+            external_id=self.external_id,
+            version=self.version,
+        )
+
+    @field_serializer("views", mode="plain")
+    @classmethod
+    def serialize_views(
+        cls, views: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if views is None:
+            return None
+        output: list[dict[str, Any]] = []
+        for view in views:
+            dumped = view.model_dump(**vars(info))
+            dumped["type"] = "view"
+            output.append(dumped)
+        return output
+
+
+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/_data_types.py

@@ -0,0 +1,195 @@
+import re
+from abc import ABC
+from collections.abc import Mapping
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter, field_validator
+
+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, ViewReference
+
+
+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", exclude=False)
+
+
+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.",
+    )
+    # This property is only available in the response object. It will be ignored in the request object.
+    # In the request object, use ViewCoreProperty.source instead.
+    source: ViewReference | None = Field(
+        None, description="The hint showing the view what the direct relation points to.", exclude=True
+    )
+
+
+class EnumValue(BaseModelObject):
+    name: str | None = Field(
+        None,
+        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.",
+    )
+
+
+_ENUM_KEY = re.compile(ENUM_VALUE_IDENTIFIER_PATTERN)
+
+
+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.",
+        min_length=1,
+        max_length=128,
+        pattern=ENUM_VALUE_IDENTIFIER_PATTERN,
+    )
+    values: dict[str, EnumValue] = Field(
+        description="A set of all possible values for the enum property.",
+        min_length=1,
+        max_length=32,
+    )
+
+    @field_validator("values", mode="after")
+    def _valid_enum_value(cls, val: dict[str, EnumValue]) -> dict[str, EnumValue]:
+        errors: list[str] = []
+        for key in val.keys():
+            if not _ENUM_KEY.match(key):
+                errors.append(
+                    f"Enum value {key!r} is not valid. Enum values must match "
+                    f"the pattern: {ENUM_VALUE_IDENTIFIER_PATTERN}"
+                )
+            if len(key) > 128 or len(key) < 1:
+                errors.append(f"Enum value {key!r} must be between 1 and 128 characters long.")
+            if key.lower() in FORBIDDEN_ENUM_VALUES:
+                errors.append(
+                    f"Enum value {key!r} cannot be any of the following reserved values: {FORBIDDEN_ENUM_VALUES}"
+                )
+        if errors:
+            raise ValueError(";".join(errors))
+        return val
+
+
+DataType = Annotated[
+    TextProperty
+    | Float32Property
+    | Float64Property
+    | BooleanProperty
+    | Int32Property
+    | Int64Property
+    | TimestampProperty
+    | DateProperty
+    | JSONProperty
+    | TimeseriesCDFExternalIdReference
+    | FileCDFExternalIdReference
+    | SequenceCDFExternalIdReference
+    | EnumProperty
+    | DirectNodeRelation,
+    Field(discriminator="type"),
+]
+
+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,28 @@
+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 ._references import (
+    ContainerReference,
+    DataModelReference,
+    SpaceReference,
+    ViewReference,
+)
+from ._space import SpaceRequest
+from ._views import ViewRequest
+
+DataModelResource: TypeAlias = SpaceRequest | DataModelRequest | ViewRequest | ContainerRequest
+
+T_DataModelResource = TypeVar("T_DataModelResource", bound=DataModelResource)
+
+ResourceId: TypeAlias = SpaceReference | DataModelReference | ViewReference | ContainerReference
+
+T_ResourceId = TypeVar("T_ResourceId", bound=ResourceId)
+
+
+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

@@ -0,0 +1,30 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from cognite.neat._utils.useful_types import BaseModelObject
+
+from ._types import Bool
+
+
+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")]
+
+IndexAdapter: TypeAdapter[Index] = TypeAdapter(Index)

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

@@ -0,0 +1,96 @@
+from pydantic import BaseModel, Field
+
+from cognite.neat._client.statistics_api import StatisticsResponse
+
+from ._data_types import DataType, DirectNodeRelation, Int32Property, Int64Property
+
+
+class SpaceLimit(BaseModel):
+    """Limits for spaces."""
+
+    limit: int = 100
+
+
+class ListablePropertyLimits(BaseModel):
+    """Limits for list properties."""
+
+    limit: int = Field(2_000, description="Max limit for types other than int32/64 with b-tree index.")
+    int32_with_btree_limit: int = Field(600, description="Max limit for Int32 properties with B-tree index.")
+    int64_with_btree_limit: int = Field(300, description="Max limit for Int64 properties with B-tree index.")
+    # defaults
+    direct_default: int = Field(100, description="Default limit for direct relations.")
+    other_default: int = Field(1_000, description="Default limit for types other than direct.")
+
+    def __call__(self, data_type: DataType, has_btree_index: bool = False) -> int:
+        """Get the limit for a specific data type."""
+        if isinstance(data_type, Int32Property) and has_btree_index:
+            return self.int32_with_btree_limit
+        if isinstance(data_type, Int64Property) and has_btree_index:
+            return self.int64_with_btree_limit
+        return self.limit
+
+    def default(self, data_type: DataType) -> int:
+        """Get the default limit for a specific data type."""
+        if isinstance(data_type, DirectNodeRelation):
+            return self.direct_default
+        return self.other_default
+
+
+class ContainerPropertyLimits(BaseModel):
+    limit: int = Field(100, description="Limit of properties per container.")
+    enums: int = Field(32, description="Limit of enums per property.")
+    total: int = Field(25_000, description="Total limit of properties.")
+
+    listable: ListablePropertyLimits = Field(default_factory=ListablePropertyLimits)
+
+    def __call__(self) -> int:
+        return self.limit
+
+
+class ContainerLimits(BaseModel):
+    """Limits for containers."""
+
+    limit: int = 1_000
+    properties: ContainerPropertyLimits = Field(default_factory=ContainerPropertyLimits)
+
+
+class ViewLimits(BaseModel):
+    """Limits for views."""
+
+    limit: int = 2_000
+    versions: int = 100
+    properties: int = 300
+    implements: int = 10
+    containers: int = 10
+
+
+class DataModelLimits(BaseModel):
+    """Limits for data models."""
+
+    limit: int = 500
+    versions: int = Field(100, description="Limit of versions per data model.")
+    views: int = Field(100, description="Limit of views per data model.")
+
+
+class SchemaLimits(BaseModel):
+    """CDF Data Modeling resource limits."""
+
+    spaces: SpaceLimit = Field(default_factory=SpaceLimit)
+    containers: ContainerLimits = Field(default_factory=ContainerLimits)
+    views: ViewLimits = Field(default_factory=ViewLimits)
+    data_models: DataModelLimits = Field(default_factory=DataModelLimits)
+
+    @classmethod
+    def from_api_response(cls, response: StatisticsResponse) -> "SchemaLimits":
+        """Populate limits from API response."""
+        # Implementation to parse and set limits from response can be added here
+
+        container = ContainerLimits(**response.containers.model_dump())
+        container.properties.limit = response.container_properties.limit
+
+        return cls(
+            spaces=SpaceLimit(**response.spaces.model_dump()),
+            containers=container,
+            views=ViewLimits(**response.views.model_dump()),
+            data_models=DataModelLimits(**response.data_models.model_dump()),
+        )