cognite-neat 1.0.25__py3-none-any.whl → 1.0.26__py3-none-any.whl

cognite/neat/_client/api.py

@@ -1,8 +1,178 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from typing import Any, Generic, Literal, TypeAlias, TypeVar
+
+from pydantic import BaseModel, JsonValue, TypeAdapter
+
 from cognite.neat._client.config import NeatClientConfig
-from cognite.neat._utils.http_client import HTTPClient
+from cognite.neat._data_model.models.dms._base import T_Resource, T_Response
+from cognite.neat._utils.collection import chunker_sequence
+from cognite.neat._utils.http_client import HTTPClient, ParametersRequest, SimpleBodyRequest, SuccessResponse
+from cognite.neat._utils.useful_types import T_Reference
+
+from .data_classes import PagedResponse
+
+_T_BaseModel = TypeVar("_T_BaseModel", bound=BaseModel)
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: Literal["GET", "POST"]
+    path: str
+    item_limit: int
 
 
-class NeatAPI:
-    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+APIMethod: TypeAlias = Literal["apply", "retrieve", "delete", "list"]
+
+
+class NeatAPI(Generic[T_Reference, T_Resource, T_Response], ABC):
+    def __init__(
+        self, neat_config: NeatClientConfig, http_client: HTTPClient, endpoint_map: dict[APIMethod, Endpoint]
+    ) -> None:
         self._config = neat_config
         self._http_client = http_client
+        self._method_endpoint_map = endpoint_map
+
+    @abstractmethod
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[T_Response]:
+        """Parse a single item response."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _validate_id_response(self, response: SuccessResponse) -> list[T_Reference]:
+        """Parse a single item response."""
+        raise NotImplementedError()
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint."""
+        return self._config.create_api_url(path)
+
+    def _request_item_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_Response]:
+        response_items: list[T_Response] = []
+        for response in self._chunk_requests(items, method, extra_body):
+            response_items.extend(self._validate_page_response(response).items)
+        return response_items
+
+    def _request_id_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_Reference]:
+        response_items: list[T_Reference] = []
+        for response in self._chunk_requests(items, method, extra_body):
+            response_items.extend(self._validate_id_response(response))
+        return response_items
+
+    def _chunk_requests(
+        self,
+        items: Sequence[_T_BaseModel],
+        method: APIMethod,
+        extra_body: dict[str, Any] | None = None,
+    ) -> Iterable[SuccessResponse]:
+        """Send requests in chunks and yield responses.
+
+        Args:
+            items: The items to process.
+            method: The API method to use. This is used ot look the up the endpoint.
+            extra_body: Optional extra body content to include in the request.
+
+        Yields:
+            The successful responses from the API.
+        """
+        # Filter out None
+        endpoint = self._method_endpoint_map[method]
+
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = SimpleBodyRequest(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body=TypeAdapter(dict[str, JsonValue]).dump_json(
+                    {
+                        "items": [item.model_dump(by_alias=True) for item in chunk],
+                        **(extra_body or {}),
+                    },
+                ),
+            )
+            response = self._http_client.request_with_retries(request)
+            response.raise_for_status()
+            yield response.success_response
+
+    @classmethod
+    def _filter_out_none_values(cls, params: dict[str, Any] | None) -> dict[str, Any] | None:
+        request_params: dict[str, Any] | None = None
+        if params:
+            request_params = {k: v for k, v in params.items() if v is not None}
+        return request_params
+
+    def _paginate(
+        self,
+        limit: int,
+        cursor: str | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> PagedResponse[T_Response]:
+        """Fetch a single page of resources.
+
+        Args:
+            params: Query parameters for the request. Supported parameters depend on
+                the resource type but typically include:
+                - cursor: Cursor for pagination
+                - limit: Maximum number of items (defaults to list limit)
+                - space: Filter by space
+                - includeGlobal: Whether to include global resources
+            limit: Maximum number of items to return in the page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            A Page containing the items and the cursor for the next page.
+        """
+        endpoint = self._method_endpoint_map["list"]
+        if not (0 < limit <= endpoint.item_limit):
+            raise ValueError(f"Limit must be between 1 and {endpoint.item_limit}, got {limit}.")
+        if endpoint.method != "GET":
+            raise NotImplementedError(f"Pagination not implemented for method {endpoint.method}.")
+        request_params = self._filter_out_none_values(params) or {}
+        request_params["limit"] = limit
+        if cursor is not None:
+            request_params["cursor"] = cursor
+        request = ParametersRequest(
+            endpoint_url=self._make_url(endpoint.path),
+            method=endpoint.method,
+            parameters=request_params,
+        )
+        result = self._http_client.request_with_retries(request)
+        result.raise_for_status()
+        return self._validate_page_response(result.success_response)
+
+    def _iterate(
+        self,
+        limit: int | None = None,
+        cursor: str | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Iterable[list[T_Response]]:
+        """Iterate over all resources, handling pagination automatically."""
+        next_cursor = cursor
+        total = 0
+        endpoint = self._method_endpoint_map["list"]
+        while True:
+            page_limit = endpoint.item_limit if limit is None else min(limit - total, endpoint.item_limit)
+            page = self._paginate(limit=page_limit, cursor=next_cursor, params=params)
+            yield page.items
+            total += len(page.items)
+            if page.next_cursor is None or (limit is not None and total >= limit):
+                break
+            next_cursor = page.next_cursor
+
+    def _list(
+        self,
+        limit: int | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> list[T_Response]:
+        """List all resources, handling pagination automatically."""
+        return [item for batch in self._iterate(limit=limit, params=params) for item in batch]

cognite/neat/_client/containers_api.py

@@ -1,18 +1,32 @@
-from __future__ import annotations
-
 from collections.abc import Sequence
 
-from cognite.neat._data_model.models.dms import ContainerReference, ContainerRequest, ContainerResponse, DataModelBody
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._data_model.models.dms import ContainerReference, ContainerRequest, ContainerResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import ContainerFilter
 
 
 class ContainersAPI(NeatAPI):
-    ENDPOINT = "/models/containers"
-    LIST_REQUEST_LIMIT = 1000
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "models/containers", item_limit=100),
+                "retrieve": Endpoint("POST", "models/containers/byids", item_limit=100),
+                "delete": Endpoint("POST", "models/containers/delete", item_limit=100),
+                "list": Endpoint("GET", "models/containers", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[ContainerResponse]:
+        return PagedResponse[ContainerResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[ContainerReference]:
+        return PagedResponse[ContainerReference].model_validate_json(response.body).items
 
     def apply(self, items: Sequence[ContainerRequest]) -> list[ContainerResponse]:
         """Apply (create or update) containers in CDF.
@@ -22,25 +36,9 @@ class ContainersAPI(NeatAPI):
         Returns:
             List of ContainerResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot apply more than 100 containers at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ContainerResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "apply")
 
-    def retrieve(
-        self,
-        items: list[ContainerReference],
-    ) -> list[ContainerResponse]:
+    def retrieve(self, items: list[ContainerReference]) -> list[ContainerResponse]:
         """Retrieve containers by their identifiers.
 
         Args:
@@ -49,21 +47,7 @@ class ContainersAPI(NeatAPI):
         Returns:
             List of ContainerResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 1000:
-            raise ValueError("Cannot retrieve more than 1000 containers at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ContainerResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "retrieve")
 
     def delete(self, items: list[ContainerReference]) -> list[ContainerReference]:
         """Delete containers by their identifiers.
@@ -74,27 +58,10 @@ class ContainersAPI(NeatAPI):
         Returns:
             List of ContainerReference objects representing the deleted containers.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot delete more than 100 containers at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ContainerReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(items, "delete")
 
     def list(
-        self,
-        space: str | None = None,
-        include_global: bool = False,
-        limit: int | None = 10,
+        self, space: str | None = None, include_global: bool = False, limit: int | None = 10
     ) -> list[ContainerResponse]:
         """List containers in CDF Project.
 
@@ -106,33 +73,5 @@ class ContainersAPI(NeatAPI):
         Returns:
             List of ContainerResponse objects.
         """
-        if limit is not None and limit < 0:
-            raise ValueError("Limit must be non-negative.")
-        elif limit is not None and limit == 0:
-            return []
-        parameters: dict[str, PrimitiveType] = {"includeGlobal": include_global}
-        if space is not None:
-            parameters["space"] = space
-        cursor: str | None = None
-        container_responses: list[ContainerResponse] = []
-        while True:
-            if cursor is not None:
-                parameters["cursor"] = cursor
-            if limit is None:
-                parameters["limit"] = self.LIST_REQUEST_LIMIT
-            else:
-                parameters["limit"] = min(self.LIST_REQUEST_LIMIT, limit - len(container_responses))
-            result = self._http_client.request_with_retries(
-                ParametersRequest(
-                    endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                    method="GET",
-                    parameters=parameters,
-                )
-            )
-            result.raise_for_status()
-            result = PagedResponse[ContainerResponse].model_validate_json(result.success_response.body)
-            container_responses.extend(result.items)
-            cursor = result.next_cursor
-            if cursor is None or (limit is not None and len(container_responses) >= limit):
-                break
-        return container_responses
+        filter = ContainerFilter(space=space, include_global=include_global)
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_client/data_model_api.py

@@ -1,15 +1,32 @@
 from collections.abc import Sequence
 
-from cognite.neat._data_model.models.dms import DataModelBody, DataModelReference, DataModelRequest, DataModelResponse
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._data_model.models.dms import DataModelReference, DataModelRequest, DataModelResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import DataModelFilter
 
 
 class DataModelsAPI(NeatAPI):
-    ENDPOINT = "/models/datamodels"
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/datamodels", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/datamodels/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/datamodels/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/datamodels", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[DataModelResponse]:
+        return PagedResponse[DataModelResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[DataModelReference]:
+        return PagedResponse[DataModelReference].model_validate_json(response.body).items
 
     def apply(self, data_models: Sequence[DataModelRequest]) -> list[DataModelResponse]:
         """Apply (create or update) data models in CDF.
@@ -19,26 +36,9 @@ class DataModelsAPI(NeatAPI):
         Returns:
             List of DataModelResponse objects.
         """
-        if not data_models:
-            return []
-        if len(data_models) > 100:
-            raise ValueError("Cannot apply more than 100 data models at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=data_models),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[DataModelResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(data_models, "apply")
 
-    def retrieve(
-        self,
-        items: list[DataModelReference],
-    ) -> list[DataModelResponse]:
+    def retrieve(self, items: list[DataModelReference]) -> list[DataModelResponse]:
         """Retrieve data models by their identifiers.
 
         Args:
@@ -46,21 +46,7 @@ class DataModelsAPI(NeatAPI):
         Returns:
             List of DataModelResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot retrieve more than 1000 containers at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[DataModelResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "retrieve")
 
     def delete(self, items: list[DataModelReference]) -> list[DataModelReference]:
         """Delete data models by their identifiers.
@@ -70,46 +56,32 @@ class DataModelsAPI(NeatAPI):
         Returns:
             List of DataModelReference objects representing the deleted data models.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot delete more than 100 data models at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[DataModelReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(items, "delete")
 
     def list(
         self,
         space: str | None = None,
         all_versions: bool = False,
+        inline_views: bool = False,
         include_global: bool = False,
-        limit: int = 10,
+        limit: int | None = 10,
     ) -> list[DataModelResponse]:
-        """List data models in CDF Project."""
-        if limit > 1000:
-            raise ValueError("Pagination is not (yet) supported for listing data models. The maximum limit is 1000.")
-        parameters: dict[str, PrimitiveType] = {
-            "allVersions": all_versions,
-            "includeGlobal": include_global,
-            "limit": limit,
-        }
-        if space is not None:
-            parameters["space"] = space
-        result = self._http_client.request_with_retries(
-            ParametersRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="GET",
-                parameters=parameters,
-            )
+        """List data models in CDF Project.
+
+        Args:
+            space: If specified, only data models in this space are returned.
+            all_versions: If True, return all versions. If False, only return the latest version.
+            inline_views: If True, include views inline in the response.
+            include_global: If True, include global data models.
+            limit: Maximum number of data models to return. If None, return all data models.
+
+        Returns:
+            List of DataModelResponse objects.
+        """
+        filter = DataModelFilter(
+            space=space,
+            all_versions=all_versions,
+            inline_views=inline_views,
+            include_global=include_global,
         )
-        result.raise_for_status()
-        result = PagedResponse[DataModelResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_client/filters.py

@@ -0,0 +1,40 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class BaseModelRequest(BaseModel):
+    """Base class for all object. This includes resources and nested objects."""
+
+
+class Filter(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True)
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the object to a dictionary.
+
+        Args:
+            camel_case (bool): Whether to use camelCase for the keys. Default is True.
+
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+
+
+class DataModelingFilter(Filter):
+    space: str | None = None
+    include_global: bool | None = None
+
+
+class ContainerFilter(DataModelingFilter):
+    used_for: Literal["node", "edge", "record", "all"] | None = None
+
+
+class ViewFilter(DataModelingFilter):
+    include_inherited_properties: bool | None = None
+    all_versions: bool | None = None
+
+
+class DataModelFilter(DataModelingFilter):
+    inline_views: bool | None = None
+    all_versions: bool | None = None

cognite/neat/_client/spaces_api.py

@@ -1,18 +1,37 @@
 from __future__ import annotations
 
-from cognite.neat._data_model.models.dms import DataModelBody, SpaceRequest, SpaceResponse
+from collections.abc import Sequence
+
+from cognite.neat._data_model.models.dms import SpaceRequest, SpaceResponse
 from cognite.neat._data_model.models.dms._references import SpaceReference
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import DataModelingFilter
 
 
 class SpacesAPI(NeatAPI):
-    ENDPOINT = "/models/spaces"
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/spaces", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/spaces/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/spaces/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/spaces", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[SpaceResponse]:
+        return PagedResponse[SpaceResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[SpaceReference]:
+        return PagedResponse[SpaceReference].model_validate_json(response.body).items
 
-    def apply(self, spaces: list[SpaceRequest]) -> list[SpaceResponse]:
+    def apply(self, spaces: Sequence[SpaceRequest]) -> list[SpaceResponse]:
         """Apply (create or update) spaces in CDF.
 
         Args:
@@ -20,20 +39,7 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceResponse objects.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 100:
-            raise ValueError("Cannot apply more than 100 spaces at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(spaces, "apply")
 
     def retrieve(self, spaces: list[SpaceReference]) -> list[SpaceResponse]:
         """Retrieve spaces by their identifiers.
@@ -44,21 +50,7 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceResponse objects.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 1000:
-            raise ValueError("Cannot retrieve more than 1000 spaces at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                method="POST",
-                body=ItemIDBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(spaces, "retrieve")
 
     def delete(self, spaces: list[SpaceReference]) -> list[SpaceReference]:
         """Delete spaces by their identifiers.
@@ -68,48 +60,21 @@ class SpacesAPI(NeatAPI):
         Returns:
             List of SpaceReference objects representing the deleted spaces.
         """
-        if not spaces:
-            return []
-        if len(spaces) > 100:
-            raise ValueError("Cannot delete more than 100 spaces at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=spaces),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(spaces, "delete")
 
     def list(
         self,
         include_global: bool = False,
-        limit: int = 10,
+        limit: int | None = 10,
     ) -> list[SpaceResponse]:
         """List spaces in CDF Project.
 
         Args:
             include_global: If True, include global spaces.
-            limit: Maximum number of spaces to return. Max is 1000.
+            limit: Maximum number of spaces to return. If None, return all spaces.
 
         Returns:
             List of SpaceResponse objects.
         """
-        if limit > 1000:
-            raise ValueError("Pagination is not (yet) supported for listing spaces. The maximum limit is 1000.")
-        parameters: dict[str, PrimitiveType] = {
-            "includeGlobal": include_global,
-            "limit": limit,
-        }
-        result = self._http_client.request_with_retries(
-            ParametersRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="GET",
-                parameters=parameters,
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[SpaceResponse].model_validate_json(result.success_response.body)
-        return result.items
+        filter = DataModelingFilter(include_global=include_global)
+        return self._list(limit=limit, params=filter.dump())

cognite/neat/_client/statistics_api.py

@@ -1,9 +1,14 @@
-from cognite.neat._client.api import NeatAPI
-from cognite.neat._client.data_classes import StatisticsResponse
-from cognite.neat._utils.http_client import ParametersRequest
+from cognite.neat._utils.http_client import HTTPClient, ParametersRequest
 
+from .config import NeatClientConfig
+from .data_classes import StatisticsResponse
+
+
+class StatisticsAPI:
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        self._config = neat_config
+        self._http_client = http_client
 
-class StatisticsAPI(NeatAPI):
     def project(self) -> StatisticsResponse:
         """Retrieve project-wide usage data and limits.
 

cognite/neat/_client/views_api.py

@@ -2,46 +2,45 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from cognite.neat._data_model.models.dms import DataModelBody, ViewReference, ViewRequest, ViewResponse
-from cognite.neat._utils.collection import chunker_sequence
-from cognite.neat._utils.http_client import ItemIDBody, ItemsRequest, ParametersRequest
-from cognite.neat._utils.useful_types import PrimitiveType
+from cognite.neat._data_model.models.dms import ViewReference, ViewRequest, ViewResponse
+from cognite.neat._utils.http_client import HTTPClient, SuccessResponse
 
-from .api import NeatAPI
+from .api import Endpoint, NeatAPI
+from .config import NeatClientConfig
 from .data_classes import PagedResponse
+from .filters import ViewFilter
 
 
 class ViewsAPI(NeatAPI):
-    ENDPOINT = "/models/views"
-    LIST_REQUEST_LIMIT = 1000
+    def __init__(self, neat_config: NeatClientConfig, http_client: HTTPClient) -> None:
+        super().__init__(
+            neat_config,
+            http_client,
+            endpoint_map={
+                "apply": Endpoint("POST", "/models/views", item_limit=100),
+                "retrieve": Endpoint("POST", "/models/views/byids", item_limit=100),
+                "delete": Endpoint("POST", "/models/views/delete", item_limit=100),
+                "list": Endpoint("GET", "/models/views", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(self, response: SuccessResponse) -> PagedResponse[ViewResponse]:
+        return PagedResponse[ViewResponse].model_validate_json(response.body)
+
+    def _validate_id_response(self, response: SuccessResponse) -> list[ViewReference]:
+        return PagedResponse[ViewReference].model_validate_json(response.body).items
 
     def apply(self, items: Sequence[ViewRequest]) -> list[ViewResponse]:
         """Create or update views in CDF Project.
+
         Args:
             items: List of ViewRequest objects to create or update.
         Returns:
             List of ViewResponse objects.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot apply more than 100 views at once.")
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                body=DataModelBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_item_response(items, "apply")
 
-    def retrieve(
-        self,
-        items: list[ViewReference],
-        include_inherited_properties: bool = True,
-    ) -> list[ViewResponse]:
+    def retrieve(self, items: list[ViewReference], include_inherited_properties: bool = True) -> list[ViewResponse]:
         """Retrieve views by their identifiers.
 
         Args:
@@ -51,42 +50,20 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        results: list[ViewResponse] = []
-        for chunk in chunker_sequence(items, 100):
-            batch = self._http_client.request_with_retries(
-                ItemsRequest(
-                    endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/byids"),
-                    method="POST",
-                    body=ItemIDBody(items=chunk),
-                    parameters={"includeInheritedProperties": include_inherited_properties},
-                )
-            )
-            batch.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(batch.success_response.body)
-            results.extend(result.items)
-        return results
+        return self._request_item_response(
+            items, "retrieve", extra_body={"includeInheritedProperties": include_inherited_properties}
+        )
 
     def delete(self, items: list[ViewReference]) -> list[ViewReference]:
         """Delete views by their identifiers.
 
         Args:
             items: List of (space, external_id, version) tuples identifying the views to delete.
+
+        Returns:
+            List of ViewReference objects representing the deleted views.
         """
-        if not items:
-            return []
-        if len(items) > 100:
-            raise ValueError("Cannot delete more than 100 views at once.")
-
-        result = self._http_client.request_with_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                body=ItemIDBody(items=items),
-            )
-        )
-        result.raise_for_status()
-        result = PagedResponse[ViewReference].model_validate_json(result.success_response.body)
-        return result.items
+        return self._request_id_response(items, "delete")
 
     def list(
         self,
@@ -108,37 +85,10 @@ class ViewsAPI(NeatAPI):
         Returns:
             List of ViewResponse objects.
         """
-        if limit is not None and limit < 0:
-            raise ValueError("Limit must be non-negative.")
-        elif limit is not None and limit == 0:
-            return []
-        parameters: dict[str, PrimitiveType] = {
-            "allVersions": all_versions,
-            "includeInheritedProperties": include_inherited_properties,
-            "includeGlobal": include_global,
-        }
-        if space is not None:
-            parameters["space"] = space
-        cursor: str | None = None
-        view_responses: list[ViewResponse] = []
-        while True:
-            if cursor is not None:
-                parameters["cursor"] = cursor
-            if limit is None:
-                parameters["limit"] = self.LIST_REQUEST_LIMIT
-            else:
-                parameters["limit"] = min(self.LIST_REQUEST_LIMIT, limit - len(view_responses))
-            result = self._http_client.request_with_retries(
-                ParametersRequest(
-                    endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                    method="GET",
-                    parameters=parameters,
-                )
-            )
-            result.raise_for_status()
-            result = PagedResponse[ViewResponse].model_validate_json(result.success_response.body)
-            view_responses.extend(result.items)
-            cursor = result.next_cursor
-            if cursor is None or (limit is not None and len(view_responses) >= limit):
-                break
-        return view_responses
+        filter = ViewFilter(
+            space=space,
+            all_versions=all_versions,
+            include_inherited_properties=include_inherited_properties,
+            include_global=include_global,
+        )
+        return self._list(limit=limit, params=filter.dump())

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

@@ -22,6 +22,9 @@ class WriteableResource(Resource, Generic[T_Resource], ABC):
         raise NotImplementedError()
 
 
+T_Response = TypeVar("T_Response", bound=WriteableResource)
+
+
 class APIResource(Generic[T_Reference], ABC):
     """Base class for all API data modeling resources."""
 

cognite/neat/_utils/http_client/_client.py

@@ -167,7 +167,9 @@ class HTTPClient:
         if isinstance(item, BodyRequest):
             data = item.data()
             if not global_config.disable_gzip:
-                data = gzip.compress(data.encode("utf-8"))
+                if isinstance(data, str):
+                    data = data.encode("utf-8")
+                data = gzip.compress(data)
         return self.session.request(
             method=item.method,
             url=item.endpoint_url,

cognite/neat/_utils/http_client/_data_classes.py

@@ -118,14 +118,14 @@ class BodyRequest(ParametersRequest, ABC):
     """Base class for HTTP request messages with a body"""
 
     @abstractmethod
-    def data(self) -> str:
+    def data(self) -> str | bytes:
         raise NotImplementedError()
 
 
 class SimpleBodyRequest(BodyRequest):
-    body: str
+    body: str | bytes
 
-    def data(self) -> str:
+    def data(self) -> str | bytes:
         return self.body
 
 

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "1.0.25"
+__version__ = "1.0.26"
 __engine__ = "^2.0.4"

{cognite_neat-1.0.25.dist-info → cognite_neat-1.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.25
+Version: 1.0.26
 Summary: Knowledge graph transformation
 Author: Nikola Vasiljevic, Anders Albert
 Author-email: Nikola Vasiljevic <nikola.vasiljevic@cognite.com>, Anders Albert <anders.albert@cognite.com>

{cognite_neat-1.0.25.dist-info → cognite_neat-1.0.26.dist-info}/RECORD

@@ -1,19 +1,20 @@
 cognite/neat/__init__.py,sha256=YU2PPtzByiyLcUeWePkckaL9v-ZxoR6OF6wiq-2XVwM,297
 cognite/neat/_client/__init__.py,sha256=DIHMeggZ81rVJwO97E5PVP8AwVAhhLpjBQu7Ns3_xdc,178
-cognite/neat/_client/api.py,sha256=nbxCdWBXcTVM6MrQeT_VpB6ehfoI544JHPFq-ejQKCY,292
+cognite/neat/_client/api.py,sha256=VOtXyr9-Ouxkl3nWUj6fffr-9VG6wzVRGWSr_QqR5d8,6915
 cognite/neat/_client/client.py,sha256=h0HELAHiBFxMNInkDu4AzbgfEIXqeM0BqqnMBmXjgi0,903
 cognite/neat/_client/config.py,sha256=eIIdWaA13yncRP6X7vTYsTpmXmVcmkhZPv5oPnLUEVc,1484
-cognite/neat/_client/containers_api.py,sha256=7bVIlL5PwoAG5Bks1ortW_bCG8iTkFqFVyL05pdJ3Pw,5176
+cognite/neat/_client/containers_api.py,sha256=zFHb9SwfwqAxUkrEStLBV8BDSvRWvBBOY8mVuCIOWQU,3116
 cognite/neat/_client/data_classes.py,sha256=HYPsrAJGVCUmlWTSIxJgAnIHAOzcyDveMM6Z-cuA92M,1404
-cognite/neat/_client/data_model_api.py,sha256=ogVHOabQ3HTqWaaoiGClmbtYdP-pl6DPN2zmPdH5LWY,4253
+cognite/neat/_client/data_model_api.py,sha256=fxJ77RbKd8UAsm4jfDH3P16Jp-GwKWPrxx2jyA_xCnk,3518
+cognite/neat/_client/filters.py,sha256=1tPpbp_GFAh7Jq5tdwUvZz6nOoWB36zIxa_ZO-1UER0,1138
 cognite/neat/_client/init/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_client/init/credentials.py,sha256=8PCKk-rc3rxG3l9vNiY3DklIziJgJpBr9nleozS7BZw,2385
 cognite/neat/_client/init/env_vars.py,sha256=9nOEVABp4rI2TtFHCMItLouQ5MXFL0zzL4PTclT9m-c,5469
 cognite/neat/_client/init/interactive.py,sha256=YVnsvRblQJPojf24dA050gVlrrqADK8afSQ6hkXn7Cs,4801
 cognite/neat/_client/init/main.py,sha256=D-9bsor07T84iFnTZLnhIFA1Xey9zsooHaDhXVeNdos,2508
-cognite/neat/_client/spaces_api.py,sha256=xHtSMt_2k2YwZ5_8kH2dfa7fWxQQrky7wra4Ar2jwqs,4111
-cognite/neat/_client/statistics_api.py,sha256=HcYb2nNC9M_iaI1xyjjLn2Cz1tcyu7BJeaqVps79tg4,773
-cognite/neat/_client/views_api.py,sha256=Qzk_wiLtaWszxCQFDBoWCH1yDc4GOEJsVOcL061rcK0,5639
+cognite/neat/_client/spaces_api.py,sha256=yb26ju3sKbVgiduMEbN4LDGan6vsC3z_JaW3p4FUdr0,2929
+cognite/neat/_client/statistics_api.py,sha256=5meeh0v5mxC2SMB7xGdOwMh4KkaX3DtpUjbGEPhNBJo,913
+cognite/neat/_client/views_api.py,sha256=YMaw7IaxU4gmixpd_t1u9JK9BHfNerf5DMNinGPCAa0,3692
 cognite/neat/_config.py,sha256=ZvCkcaRVAvH4-ClvinoWaLWhRJpRByqdvncGFsf5gLk,9886
 cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/_analysis.py,sha256=dN-udKm_5oD3217O4B_QIps2Hx4v50-Pu2fR0bQNQg0,23504
@@ -52,7 +53,7 @@ cognite/neat/_data_model/models/conceptual/_data_model.py,sha256=zvJZi0OqOFMviwY
 cognite/neat/_data_model/models/conceptual/_properties.py,sha256=CpF37vJYBTLT4DH4ZOu2U-JyWtkb_27V8fw52qiaE_k,4007
 cognite/neat/_data_model/models/conceptual/_property.py,sha256=blSZQxX52zaILAtjUkldPzPeysz7wnG-UGSNU5tacI8,4138
 cognite/neat/_data_model/models/dms/__init__.py,sha256=CW5NPMRrMyY4iyZgqYb8eZkRuwbbXUDSVNMWep3zEPI,5326
-cognite/neat/_data_model/models/dms/_base.py,sha256=931ODXnhrBrzf6vkjqu2IaFz8r2gGxuapn85yN_jkgg,889
+cognite/neat/_data_model/models/dms/_base.py,sha256=gCjmDca_z0ZB_NHHGOkB9CCLKNxrI_npz-4mWU2yFI0,951
 cognite/neat/_data_model/models/dms/_constants.py,sha256=TaoE9kmNVEaTl_dDrZQL7YzgP4K13ff0Rc7nr4zbIgg,1384
 cognite/neat/_data_model/models/dms/_constraints.py,sha256=cyGgDlByXAuSMWJg7Oc25fkp33LsA61M927bCzTWlbo,1458
 cognite/neat/_data_model/models/dms/_container.py,sha256=wtQbNUwtpymltT1jav8wD4kIfjaIYnvhhz1KS0ffAbo,6044
@@ -124,9 +125,9 @@ cognite/neat/_utils/_reader.py,sha256=9dXrODNNqWU0Gx1zXjRTOiiByFuDZlpQkQEzx3HAxY
 cognite/neat/_utils/auxiliary.py,sha256=YQMpqCxccex_slmLYrR5icVX9aeLbD793ou7IrbNTFs,1654
 cognite/neat/_utils/collection.py,sha256=BIwRrFbUXNPvHhEVujLHgVoDJXzdPEMScrbSBhyCibk,446
 cognite/neat/_utils/http_client/__init__.py,sha256=qaCLLLhi7H3b_cmbknX0S66KILT7JSKX1YSgZjNdd1U,786
-cognite/neat/_utils/http_client/_client.py,sha256=TO9C77LcsqX0R3Fu-mP560nnV6rP5oRXki9kxRYtBlg,9658
+cognite/neat/_utils/http_client/_client.py,sha256=4aj7gmOikLr2sLlmqyMaWonJGGy0IuGvCbJ5hIIuSPw,9732
 cognite/neat/_utils/http_client/_config.py,sha256=C8IF1JoijmVMjA_FEMgAkiD1buEV1cY5Og3t-Ecyfmk,756
-cognite/neat/_utils/http_client/_data_classes.py,sha256=McyCQZUcwkbOXdBmc99DdNsO6mQz8dNVsepDvXmaINA,10138
+cognite/neat/_utils/http_client/_data_classes.py,sha256=aPF9B8Tw6_egBulUtSXHoaUhNMCg4iLaOSu5tx1cNQs,10162
 cognite/neat/_utils/http_client/_tracker.py,sha256=EBBnd-JZ7nc_jYNFJokCHN2UZ9sx0McFLZvlceUYYic,1215
 cognite/neat/_utils/repo.py,sha256=Ex_lW7qd4fi0YLaOJaLRwSyrN46kfMXbxecVE4mSs2I,598
 cognite/neat/_utils/text.py,sha256=-ujNaG_hLkdurKsUmZB9ZI_kJkddlCKEf8g-g_XCk10,2010
@@ -322,9 +323,9 @@ cognite/neat/_v0/session/_template.py,sha256=BNcvrW5y7LWzRM1XFxZkfR1Nc7e8UgjBClH
 cognite/neat/_v0/session/_to.py,sha256=AnsRSDDdfFyYwSgi0Z-904X7WdLtPfLlR0x1xsu_jAo,19447
 cognite/neat/_v0/session/_wizard.py,sha256=baPJgXAAF3d1bn4nbIzon1gWfJOeS5T43UXRDJEnD3c,1490
 cognite/neat/_v0/session/exceptions.py,sha256=jv52D-SjxGfgqaHR8vnpzo0SOJETIuwbyffSWAxSDJw,3495
-cognite/neat/_version.py,sha256=kEQ71HVQEACqgtyau8hgTcILi0EwbWj3B7RI2KWSEHg,45
+cognite/neat/_version.py,sha256=lZxKXnsRmb2ksFvFfpJkeZtX4W01ZenoMN457_FWsB0,45
 cognite/neat/legacy.py,sha256=eI2ecxOV8ilGHyLZlN54ve_abtoK34oXognkFv3yvF0,219
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-1.0.25.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-cognite_neat-1.0.25.dist-info/METADATA,sha256=Puzp0pIIcNYZAvb2M1YswRXTzr6pvtqk4cfBT-oeKBg,6689
-cognite_neat-1.0.25.dist-info/RECORD,,
+cognite_neat-1.0.26.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+cognite_neat-1.0.26.dist-info/METADATA,sha256=jISdpgKdsL7q8pj6OfhnOzfV6VI40aR-iYoLlnTjAP0,6689
+cognite_neat-1.0.26.dist-info/RECORD,,