cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py

@@ -1,30 +0,0 @@
-from typing import Generic, TypeVar
-
-from pydantic import BaseModel, Field, JsonValue
-
-from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import RequestResource
-
-T = TypeVar("T", bound=BaseModel)
-
-
-class PagedResponse(BaseModel, Generic[T]):
-    items: list[T]
-    next_cursor: str | None = Field(None, alias="nextCursor")
-
-
-class QueryResponse(BaseModel, Generic[T]):
-    items: dict[str, list[T]]
-    typing: dict[str, JsonValue] | None = None
-    next_cursor: dict[str, str] = Field(alias="nextCursor")
-    debug: dict[str, JsonValue] | None = None
-
-
-class InternalIdRequest(RequestResource):
-    id: int
-
-    def as_id(self) -> int:
-        return self.id
-
-    @classmethod
-    def from_ids(cls, ids: list[int]) -> list["InternalIdRequest"]:
-        return [cls(id=id_) for id_ in ids]

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -1,67 +0,0 @@
-import sys
-from abc import ABC, abstractmethod
-from collections import UserList
-from typing import TYPE_CHECKING, Any, Generic, TypeVar
-
-from pydantic import ConfigDict
-from pydantic.alias_generators import to_camel
-
-from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import BaseModelObject, RequestResource
-
-if TYPE_CHECKING:
-    from cognite.client import CogniteClient
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
-T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
-
-
-class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
-    @abstractmethod
-    def as_request_resource(self) -> T_RequestResource:
-        """Convert the response resource to a request resource."""
-        ...
-
-    def as_write(self) -> T_RequestResource:
-        """Alias for as_request_resource to match protocol signature."""
-        return self.as_request_resource()
-
-
-class Identifier(RequestResource, ABC):
-    """Base class for all identifier classes."""
-
-    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
-
-    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
-        """Dump the resource to a dictionary.
-
-        This is the default serialization method for request resources.
-        """
-        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
-
-    def as_id(self) -> Self:
-        return self
-
-
-T_Resource = TypeVar("T_Resource", bound=RequestResource | ResponseResource)
-
-
-class BaseResourceList(UserList[T_Resource]):
-    """Base class for resource lists."""
-
-    _RESOURCE: type[T_Resource]
-
-    def __init__(self, initlist: list[T_Resource] | None = None, **_: Any) -> None:
-        super().__init__(initlist or [])
-
-    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
-        return [item.dump(camel_case) for item in self.data]
-
-    @classmethod
-    def load(cls, data: list[dict[str, Any]], cognite_client: "CogniteClient | None" = None) -> Self:
-        items = [cls._RESOURCE.model_validate(item) for item in data]
-        return cls(items)  # type: ignore[arg-type]

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -1,112 +0,0 @@
-from collections.abc import Hashable
-from typing import Literal
-
-from pydantic import Field
-
-from .base import BaseModelObject, RequestResource, ResponseResource
-
-
-class NodeReference(BaseModelObject):
-    space: str
-    external_id: str
-
-
-class RevisionStatus(BaseModelObject):
-    status: Literal["Queued", "Processing", "Done", "Failed"] | None = None
-    revision_id: int | None = None
-    created_time: int | None = None
-    revision_count: int | None = None
-    types: list[str] | None = None
-
-
-class ThreeDModelRequest(RequestResource):
-    name: str
-
-    def as_id(self) -> str:
-        return self.name
-
-
-class ThreeDModelClassicRequest(ThreeDModelRequest):
-    data_set_id: int | None = None
-    metadata: dict[str, str] | None = None
-
-    def as_id(self) -> str:
-        return self.name
-
-
-class ThreeDModelDMSRequest(ThreeDModelRequest):
-    space: str
-    type: Literal["CAD", "PointCloud", "Image360"]
-    thumbnail_reference: NodeReference | None = None
-
-
-class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
-    name: str
-    id: int
-    created_time: int
-    data_set_id: int | None = None
-    metadata: dict[str, str] | None = None
-    space: str | None = None
-    last_revision_info: RevisionStatus | None = None
-
-    def as_request_resource(self) -> ThreeDModelRequest:
-        if self.space is None:
-            return ThreeDModelClassicRequest._load(self.dump())
-        else:
-            return ThreeDModelDMSRequest._load(self.dump())
-
-
-class AssetMappingDMRequest(RequestResource):
-    node_id: int
-    asset_instance_id: NodeReference
-    # These fields are part of the path request and not the body schema.
-    model_id: int = Field(exclude=True)
-    revision_id: int = Field(exclude=True)
-
-    def as_id(self) -> Hashable:
-        return (
-            self.model_id,
-            self.revision_id,
-            self.node_id,
-            self.asset_instance_id.space,
-            self.asset_instance_id.external_id,
-        )
-
-
-class AssetMappingClassicRequest(RequestResource):
-    node_id: int
-    asset_id: int | None = None
-    asset_instance_id: NodeReference | None = None
-    # These fields are part of the path request and not the body schema.
-    model_id: int = Field(exclude=True)
-    revision_id: int = Field(exclude=True)
-
-    def as_id(self) -> Hashable:
-        if self.asset_id:
-            return self.model_id, self.revision_id, self.node_id, self.asset_id
-        elif self.asset_instance_id:
-            return (
-                self.model_id,
-                self.revision_id,
-                self.node_id,
-                self.asset_instance_id.space,
-                self.asset_instance_id.external_id,
-            )
-        else:
-            raise AttributeError("asset_id or asset_instance_id is required")
-
-
-class AssetMappingResponse(ResponseResource[AssetMappingClassicRequest]):
-    node_id: int
-    asset_id: int | None = None
-    asset_instance_id: NodeReference | None = None
-    tree_index: int | None = None
-    subtree_size: int | None = None
-    # These fields are part of the path request and response, but they are included here for convenience.
-    model_id: int = Field(exclude=True)
-    revision_id: int = Field(exclude=True)
-
-    def as_request_resource(self) -> AssetMappingClassicRequest:
-        return AssetMappingClassicRequest.model_validate(
-            {**self.dump(), "modelId": self.model_id, "revisionId": self.revision_id}
-        )

cognite_toolkit/_cdf_tk/commands/build_v2/build_issues.py

@@ -1,27 +0,0 @@
-import sys
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-from collections import UserList
-
-from pydantic import BaseModel
-
-from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning, WarningList
-
-
-class BuildIssue(BaseModel):
-    """Issue with the build. Can have a recommendation for the user to improve the build."""
-
-    description: str
-
-
-class BuildIssueList(UserList[BuildIssue]):
-    """List of build issues."""
-
-    @classmethod
-    def from_warning_list(cls, warning_list: WarningList[ToolkitWarning]) -> Self:
-        """Create a BuildIssueList from a WarningList."""
-        return cls([BuildIssue(description=warning.get_message()) for warning in warning_list])

cognite_toolkit/_cdf_tk/utils/http_client/_data_classes2.py

@@ -1,247 +0,0 @@
-import gzip
-import sys
-from abc import ABC, abstractmethod
-from collections import UserList
-from collections.abc import Hashable, Sequence
-from typing import Any, Literal
-
-import httpx
-from cognite.client import global_config
-from pydantic import BaseModel, ConfigDict, Field, JsonValue, TypeAdapter, model_validator
-from pydantic.alias_generators import to_camel
-
-from cognite_toolkit._cdf_tk.utils.http_client._exception import ToolkitAPIError
-from cognite_toolkit._cdf_tk.utils.http_client._tracker import ItemsRequestTracker
-from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
-class HTTPResult2(BaseModel):
-    def get_success_or_raise(self) -> "SuccessResponse2":
-        """Raises an exception if any response in the list indicates a failure."""
-        if isinstance(self, SuccessResponse2):
-            return self
-        elif isinstance(self, FailedResponse2):
-            raise ToolkitAPIError(f"Request failed with status code {self.status_code}: {self.error.message}")
-        elif isinstance(self, FailedRequest2):
-            raise ToolkitAPIError(f"Request failed with error: {self.error}")
-        else:
-            raise ToolkitAPIError("Unknown HTTPResult2 type")
-
-
-class FailedRequest2(HTTPResult2):
-    error: str
-
-
-class SuccessResponse2(HTTPResult2):
-    status_code: int
-    body: str
-    content: bytes
-
-    @property
-    def body_json(self) -> dict[str, Any]:
-        """Parse the response body as JSON."""
-        return TypeAdapter(dict[str, JsonValue]).validate_json(self.body)
-
-
-class ErrorDetails2(BaseModel):
-    """This is the expected structure of error details in the CDF API"""
-
-    code: int
-    message: str
-    missing: list[JsonValue] | None = None
-    duplicated: list[JsonValue] | None = None
-    is_auto_retryable: bool | None = None
-
-    @classmethod
-    def from_response(cls, response: httpx.Response) -> "ErrorDetails2":
-        """Populate the error details from a httpx response."""
-        try:
-            res = TypeAdapter(dict[Literal["error"], ErrorDetails2]).validate_json(response.text)
-        except ValueError:
-            return cls(code=response.status_code, message=response.text)
-        return res["error"]
-
-
-class FailedResponse2(HTTPResult2):
-    status_code: int
-    body: str
-    error: ErrorDetails2
-
-
-class BaseRequestMessage(BaseModel, ABC):
-    endpoint_url: str
-    method: Literal["GET", "POST", "PATCH", "DELETE", "PUT"]
-    connect_attempt: int = 0
-    read_attempt: int = 0
-    status_attempt: int = 0
-    api_version: str | None = None
-    content_type: str = "application/json"
-    accept: str = "application/json"
-
-    parameters: dict[str, PrimitiveType] | None = None
-
-    @property
-    def total_attempts(self) -> int:
-        return self.connect_attempt + self.read_attempt + self.status_attempt
-
-    @property
-    @abstractmethod
-    def content(self) -> str | bytes | None: ...
-
-
-class RequestMessage2(BaseRequestMessage):
-    data_content: bytes | None = None
-    body_content: dict[str, JsonValue] | None = None
-
-    @model_validator(mode="before")
-    def check_data_or_body(cls, values: dict[str, Any]) -> dict[str, Any]:
-        if values.get("data_content") is not None and values.get("body_content") is not None:
-            raise ValueError("Only one of data_content or body_content can be set.")
-        return values
-
-    @property
-    def content(self) -> str | bytes | None:
-        data: str | bytes | None = None
-        if self.data_content is not None:
-            data = self.data_content
-            if not global_config.disable_gzip:
-                data = gzip.compress(data)
-        elif self.body_content is not None:
-            # We serialize using pydantic instead of json.dumps. This is because pydantic is faster
-            # and handles more complex types such as datetime, float('nan'), etc.
-            data = _BODY_SERIALIZER.dump_json(self.body_content)
-            if not global_config.disable_gzip and isinstance(data, bytes):
-                data = gzip.compress(data)
-        return data
-
-
-_BODY_SERIALIZER = TypeAdapter(dict[str, JsonValue])
-
-
-class ItemsResultMessage2(BaseModel):
-    ids: list[Hashable]
-
-
-class ItemsFailedRequest2(ItemsResultMessage2):
-    error_message: str
-
-
-class ItemsSuccessResponse2(ItemsResultMessage2):
-    status_code: int
-    body: str
-    content: bytes
-
-
-class ItemsFailedResponse2(ItemsResultMessage2):
-    status_code: int
-    error: ErrorDetails2
-    body: str
-
-
-class BaseModelObject(BaseModel):
-    """Base class for all object. This includes resources and nested objects."""
-
-    # We allow extra fields to support forward compatibility.
-    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        """Dump the resource to a dictionary.
-
-        This is the default serialization method for request resources.
-        """
-        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any]) -> "Self":
-        """Load method to match CogniteResource signature."""
-        return cls.model_validate(resource)
-
-
-class RequestResource(BaseModelObject, ABC):
-    @abstractmethod
-    def as_id(self) -> Hashable: ...
-
-
-def _set_default_tracker(data: dict[str, Any]) -> ItemsRequestTracker:
-    if "tracker" not in data or data["tracker"] is None:
-        return ItemsRequestTracker(data.get("max_failures_before_abort", 50))
-    return data["tracker"]
-
-
-class ItemsRequest2(BaseRequestMessage):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    items: Sequence[RequestResource]
-    extra_body_fields: dict[str, JsonValue] | None = None
-    max_failures_before_abort: int = 50
-    tracker: ItemsRequestTracker = Field(init=False, default_factory=_set_default_tracker, exclude=True)
-
-    @property
-    def content(self) -> str | bytes | None:
-        body: dict[str, JsonValue] = {"items": [item.dump() for item in self.items]}
-        if self.extra_body_fields:
-            body.update(self.extra_body_fields)
-        res = _BODY_SERIALIZER.dump_json(body)
-        if not global_config.disable_gzip and isinstance(res, bytes):
-            return gzip.compress(res)
-        return res
-
-    def split(self, status_attempts: int) -> list["ItemsRequest2"]:
-        """Split the request into multiple requests with a single item each."""
-        mid = len(self.items) // 2
-        if mid == 0:
-            return [self]
-        self.tracker.register_failure()
-        messages: list[ItemsRequest2] = []
-        for part in (self.items[:mid], self.items[mid:]):
-            new_request = self.model_copy(update={"items": part, "status_attempt": status_attempts})
-            new_request.tracker = self.tracker
-            messages.append(new_request)
-        return messages
-
-
-class ItemResponse(BaseModel):
-    items: list[dict[str, JsonValue]]
-
-
-class ItemsResultList(UserList[ItemsResultMessage2]):
-    def __init__(self, collection: Sequence[ItemsResultMessage2] | None = None) -> None:
-        super().__init__(collection or [])
-
-    def raise_for_status(self) -> None:
-        """Raises an exception if any response in the list indicates a failure."""
-        failed_responses = [resp for resp in self.data if isinstance(resp, ItemsFailedResponse2)]
-        failed_requests = [resp for resp in self.data if isinstance(resp, ItemsFailedRequest2)]
-        if not failed_responses and not failed_requests:
-            return
-        error_messages = "; ".join(f"Status {err.status_code}: {err.error.message}" for err in failed_responses)
-        if failed_requests:
-            if error_messages:
-                error_messages += "; "
-            error_messages += "; ".join(f"Request error: {err.error_message}" for err in failed_requests)
-        raise ToolkitAPIError(f"One or more requests failed: {error_messages}")
-
-    @property
-    def has_failed(self) -> bool:
-        """Indicates whether any response in the list indicates a failure.
-
-        Returns:
-            bool: True if there are any failed responses or requests, False otherwise.
-        """
-        for resp in self.data:
-            if isinstance(resp, ItemsFailedResponse2 | ItemsFailedRequest2):
-                return True
-        return False
-
-    def get_items(self) -> list[dict[str, JsonValue]]:
-        """Get the items from all successful responses."""
-        items: list[dict[str, JsonValue]] = []
-        for resp in self.data:
-            if isinstance(resp, ItemsSuccessResponse2):
-                body_json = ItemResponse.model_validate_json(resp.body)
-                items.extend(body_json.items)
-        return items

cognite_toolkit/_cdf_tk/utils/http_client/_exception.py

@@ -1,4 +0,0 @@
-class ToolkitAPIError(Exception):
-    """Base class for all exceptions raised by the Cognite Toolkit API client."""
-
-    pass