cognite-toolkit 0.7.55__py3-none-any.whl → 0.7.57__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/http_client/_data_classes.py

@@ -1,428 +1,151 @@
+import gzip
 from abc import ABC, abstractmethod
-from collections import UserList
-from collections.abc import Hashable, Sequence
-from dataclasses import dataclass, field
-from typing import Generic, Literal, Protocol, TypeAlias, TypeVar
+from typing import Any, Literal
 
 import httpx
-from cognite.client.utils import _json
+from cognite.client import global_config
+from pydantic import TYPE_CHECKING, BaseModel, JsonValue, TypeAdapter, model_validator
 
 from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIError
-from cognite_toolkit._cdf_tk.client.http_client._tracker import ItemsRequestTracker
-from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal, PrimitiveType
+from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
-StatusCode: TypeAlias = int
+if TYPE_CHECKING:
+    from cognite_toolkit._cdf_tk.client.http_client._item_classes import ItemsResultMessage
 
 
-@dataclass
-class HTTPMessage(ABC):
-    """Base class for HTTP messages (requests and responses)"""
+class HTTPResult(BaseModel):
+    def get_success_or_raise(self) -> "SuccessResponse":
+        """Raises an exception if any response in the list indicates a failure."""
+        if isinstance(self, SuccessResponse):
+            return self
+        elif isinstance(self, FailedResponse):
+            raise ToolkitAPIError(
+                f"Request failed with status code {self.status_code}: {self.error.message}",
+                missing=self.error.missing,  # type: ignore[arg-type]
+                duplicated=self.error.duplicated,  # type: ignore[arg-type]
+            )
+        elif isinstance(self, FailedRequest):
+            raise ToolkitAPIError(f"Request failed with error: {self.error}")
+        else:
+            raise ToolkitAPIError("Unknown HTTPResult2 type")
+
+    def as_item_response(self, item_id: str) -> "ItemsResultMessage":
+        # Avoid circular import
+        from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
+            ItemsFailedRequest,
+            ItemsFailedResponse,
+            ItemsSuccessResponse,
+        )
+
+        if isinstance(self, SuccessResponse):
+            return ItemsSuccessResponse(
+                status_code=self.status_code, content=self.content, ids=[item_id], body=self.body
+            )
+        elif isinstance(self, FailedResponse):
+            return ItemsFailedResponse(
+                status_code=self.status_code,
+                ids=[item_id],
+                body=self.body,
+                error=ErrorDetails(
+                    code=self.error.code,
+                    message=self.error.message,
+                    missing=self.error.missing,
+                    duplicated=self.error.duplicated,
+                ),
+            )
+        elif isinstance(self, FailedRequest):
+            return ItemsFailedRequest(ids=[item_id], error_message=self.error)
+        else:
+            raise ToolkitAPIError(f"Unknown {type(self).__name__} type")
+
 
-    def dump(self) -> dict[str, JsonVal]:
-        """Dumps the message to a JSON serializable dictionary.
+class FailedRequest(HTTPResult):
+    error: str
 
-        Returns:
-            dict[str, JsonVal]: The message as a dictionary.
-        """
-        # We avoid using the asdict function as we know we have a shallow structure,
-        # and this roughly ~10x faster.
-        output = self.__dict__.copy()
-        output["type"] = type(self).__name__
-        return output
 
+class SuccessResponse(HTTPResult):
+    status_code: int
+    body: str
+    content: bytes
 
-@dataclass
-class ErrorDetails:
+    @property
+    def body_json(self) -> dict[str, Any]:
+        """Parse the response body as JSON."""
+        return TypeAdapter(dict[str, JsonValue]).validate_json(self.body)
+
+
+class ErrorDetails(BaseModel):
     """This is the expected structure of error details in the CDF API"""
 
     code: int
     message: str
-    missing: list[JsonVal] | None = None
-    duplicated: list[JsonVal] | None = None
+    missing: list[JsonValue] | None = None
+    duplicated: list[JsonValue] | None = None
     is_auto_retryable: bool | None = None
 
     @classmethod
     def from_response(cls, response: httpx.Response) -> "ErrorDetails":
+        """Populate the error details from a httpx response."""
         try:
-            error_data = response.json()["error"]
-            if not isinstance(error_data, dict):
-                return cls(code=response.status_code, message=str(error_data))
-            return cls(
-                code=error_data["code"],
-                message=error_data["message"],
-                missing=error_data.get("missing"),
-                duplicated=error_data.get("duplicated"),
-                is_auto_retryable=error_data.get("isAutoRetryable"),
-            )
-        except (ValueError, KeyError):
-            # Fallback if response is not JSON or does not have expected structure
+            res = TypeAdapter(dict[Literal["error"], ErrorDetails]).validate_json(response.text)
+        except ValueError:
             return cls(code=response.status_code, message=response.text)
+        return res["error"]
 
-    def dump(self) -> dict[str, JsonVal]:
-        output: dict[str, JsonVal] = {
-            "code": self.code,
-            "message": self.message,
-        }
-        if self.missing is not None:
-            output["missing"] = self.missing
-        if self.duplicated is not None:
-            output["duplicated"] = self.duplicated
-        if self.is_auto_retryable is not None:
-            output["isAutoRetryable"] = self.is_auto_retryable
-        return output
-
-
-@dataclass
-class FailedRequestMessage(HTTPMessage):
-    error: str
-
-    def __str__(self) -> str:
-        return self.error
-
-
-@dataclass
-class ResponseMessage(HTTPMessage):
-    status_code: StatusCode
 
+class FailedResponse(HTTPResult):
+    status_code: int
+    body: str
+    error: ErrorDetails
 
-@dataclass
-class RequestMessage(HTTPMessage):
-    """Base class for HTTP request messages"""
 
+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
+    disable_gzip: bool = False
+    content_length: int | None = None
     content_type: str = "application/json"
     accept: str = "application/json"
-    content_length: int | None = None
+
+    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 create_success_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def create_failure_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def create_failed_request(self, error_message: str) -> Sequence[HTTPMessage]:
-        raise NotImplementedError()
-
-
-@dataclass
-class SuccessResponse(ResponseMessage):
-    body: str
-    content: bytes
-
-    def dump(self) -> dict[str, JsonVal]:
-        output = super().dump()
-        # We cannot serialize bytes, so we indicate its presence instead
-        output["content"] = "<bytes>" if self.content else None
-        return output
-
-
-@dataclass
-class FailedResponse(ResponseMessage):
-    body: str
-    error: ErrorDetails
-
-    def dump(self) -> dict[str, JsonVal]:
-        output = super().dump()
-        output["error"] = self.error.dump()
-        return output
-
-    def __str__(self) -> str:
-        return f"{self.error.code} | {self.error.message}"
-
-
-@dataclass
-class SimpleRequest(RequestMessage):
-    """Base class for requests with a simple success/fail response structure"""
-
-    @classmethod
-    def create_success_response(cls, response: httpx.Response) -> Sequence[ResponseMessage]:
-        return [SuccessResponse(status_code=response.status_code, body=response.text, content=response.content)]
-
-    @classmethod
-    def create_failure_response(cls, response: httpx.Response) -> Sequence[HTTPMessage]:
-        return [
-            FailedResponse(
-                status_code=response.status_code, error=ErrorDetails.from_response(response), body=response.text
-            )
-        ]
-
-    @classmethod
-    def create_failed_request(cls, error_message: str) -> Sequence[HTTPMessage]:
-        return [FailedRequestMessage(error=error_message)]
-
-
-@dataclass
-class BodyRequest(RequestMessage, ABC):
-    """Base class for HTTP request messages with a body"""
-
-    @abstractmethod
-    def data(self) -> str:
-        raise NotImplementedError()
-
+    def content(self) -> str | bytes | None: ...
 
-@dataclass
-class ParamRequest(SimpleRequest):
-    """Base class for HTTP request messages with query parameters"""
 
-    parameters: dict[str, PrimitiveType] | None = None
-
-
-@dataclass
-class SimpleBodyRequest(SimpleRequest, BodyRequest):
-    body_content: dict[str, JsonVal] = field(default_factory=dict)
-
-    def data(self) -> str:
-        return _dump_body(self.body_content)
-
-
-@dataclass
-class DataBodyRequest(SimpleRequest):
-    data_content: bytes = b""
-
-    def data(self) -> bytes:
-        return self.data_content
-
-    def dump(self) -> dict[str, JsonVal]:
-        output = super().dump()
-        # We cannot serialize bytes, so we indicate its presence instead
-        output["data_content"] = "<bytes>"
-        return output
-
-
-T_COVARIANT_ID = TypeVar("T_COVARIANT_ID", covariant=True)
-
-
-@dataclass
-class ItemMessage(Generic[T_COVARIANT_ID], ABC):
-    """Base class for message related to a specific item identified by an ID"""
-
-    ids: list[T_COVARIANT_ID] = field(default_factory=list)
-
-
-@dataclass
-class SuccessResponseItems(ItemMessage[T_COVARIANT_ID], SuccessResponse): ...
-
-
-@dataclass
-class FailedResponseItems(ItemMessage[T_COVARIANT_ID], FailedResponse): ...
-
-
-@dataclass
-class FailedRequestItems(ItemMessage[T_COVARIANT_ID], FailedRequestMessage): ...
-
-
-class RequestItem(Generic[T_COVARIANT_ID], Protocol):
-    def dump(self) -> JsonVal: ...
-
-    def as_id(self) -> T_COVARIANT_ID: ...
-
-
-@dataclass
-class ItemsRequest(Generic[T_COVARIANT_ID], BodyRequest):
-    """Requests message for endpoints that accept multiple items in a single request.
-
-    This class provides functionality to split large requests into smaller ones, handle responses for each item,
-    and manage errors effectively.
-
-    Attributes:
-        items (list[T_RequestItem]): The list of items to be sent in the request body.
-        extra_body_fields (dict[str, JsonVal]): Additional fields to include in the request body
-        max_failures_before_abort (int): The maximum number of failed split requests before aborting further splits.
-
-    """
-
-    items: list[RequestItem[T_COVARIANT_ID]] = field(default_factory=list)
-    extra_body_fields: dict[str, JsonVal] = field(default_factory=dict)
-    max_failures_before_abort: int = 50
-    tracker: ItemsRequestTracker | None = field(default=None, init=False)
+class RequestMessage(BaseRequestMessage):
+    data_content: bytes | None = None
+    body_content: dict[str, JsonValue] | None = None
 
-    def dump(self) -> dict[str, JsonVal]:
-        """Dumps the message to a JSON serializable dictionary.
-
-        This override removes the 'as_id' attribute as it is not serializable.
-
-        Returns:
-            dict[str, JsonVal]: The message as a dictionary.
-        """
-        output = super().dump()
-        output["items"] = self.dump_items()
-        if self.tracker is not None:
-            # We cannot serialize the tracker
-            del output["tracker"]
-        return output
-
-    def dump_items(self) -> list[JsonVal]:
-        """Dumps the items to a list of JSON serializable dictionaries.
-
-        Returns:
-            list[JsonVal]: The items as a list of dictionaries.
-        """
-        return [item.dump() for item in self.items]
-
-    def body(self) -> dict[str, JsonVal]:
-        if self.extra_body_fields:
-            return {"items": self.dump_items(), **self.extra_body_fields}
-        return {"items": self.dump_items()}
-
-    def data(self) -> str:
-        return _dump_body(self.body())
-
-    def split(self, status_attempts: int) -> "list[ItemsRequest]":
-        """Splits the request into two smaller requests.
-
-        This is useful for retrying requests that fail due to size limits or timeouts.
-
-        Args:
-            status_attempts: The number of status attempts to set for the new requests. This is used when the
-                request failed with a 5xx status code and we want to track the number of attempts. For 4xx errors,
-                there is at least one item causing the error, so we do not increment the status attempts, but
-                instead essentially do a binary search to find the problematic item(s).
-
-        Returns:
-            A list containing two new ItemsRequest instances, each with half of the original items.
-
-        """
-        mid = len(self.items) // 2
-        if mid == 0:
-            return [self]
-        tracker = self.tracker or ItemsRequestTracker(self.max_failures_before_abort)
-        tracker.register_failure()
-        first_half = ItemsRequest[T_COVARIANT_ID](
-            endpoint_url=self.endpoint_url,
-            method=self.method,
-            items=self.items[:mid],
-            extra_body_fields=self.extra_body_fields,
-            connect_attempt=self.connect_attempt,
-            read_attempt=self.read_attempt,
-            status_attempt=status_attempts,
-            api_version=self.api_version,
-            content_type=self.content_type,
-            accept=self.accept,
-            content_length=self.content_length,
-            max_failures_before_abort=self.max_failures_before_abort,
-        )
-        first_half.tracker = tracker
-        second_half = ItemsRequest[T_COVARIANT_ID](
-            endpoint_url=self.endpoint_url,
-            method=self.method,
-            items=self.items[mid:],
-            extra_body_fields=self.extra_body_fields,
-            connect_attempt=self.connect_attempt,
-            read_attempt=self.read_attempt,
-            status_attempt=status_attempts,
-            api_version=self.api_version,
-            content_type=self.content_type,
-            accept=self.accept,
-            content_length=self.content_length,
-            max_failures_before_abort=self.max_failures_before_abort,
-        )
-        second_half.tracker = tracker
-        return [first_half, second_half]
-
-    def create_success_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
-        ids = [item.as_id() for item in self.items]
-        return [
-            SuccessResponseItems(
-                status_code=response.status_code, ids=ids, body=response.text, content=response.content
-            )
-        ]
-
-    def create_failure_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
-        error = ErrorDetails.from_response(response)
-        ids = [item.as_id() for item in self.items]
-        return [FailedResponseItems(status_code=response.status_code, ids=ids, error=error, body=response.text)]
-
-    def create_failed_request(self, error_message: str) -> Sequence[HTTPMessage]:
-        ids = [item.as_id() for item in self.items]
-        return [FailedRequestItems(ids=ids, error=error_message)]
-
-
-class ResponseList(UserList[ResponseMessage | FailedRequestMessage]):
-    def __init__(self, collection: Sequence[ResponseMessage | FailedRequestMessage] | 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, FailedResponse)]
-        failed_requests = [resp for resp in self.data if isinstance(resp, FailedRequestMessage)]
-        if not failed_responses and not failed_requests:
-            return
-        error_messages = "; ".join(f"Status {err.status_code}: {err.error}" for err in failed_responses)
-        if failed_requests:
-            if error_messages:
-                error_messages += "; "
-            error_messages += "; ".join(f"Request error: {err.error}" for err in failed_requests)
-        raise ToolkitAPIError(f"One or more requests failed: {error_messages}")
+    @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 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, FailedResponse | FailedRequestMessage):
-                return True
-        return False
-
-    def get_first_body(self) -> dict[str, JsonVal]:
-        """Returns the body of the first successful response in the list.
-
-        Raises:
-            ValueError: If there are no successful responses with a body.
-
-        Returns:
-            dict[str, JsonVal]: The body of the first successful response.
-        """
-        for resp in self.data:
-            if isinstance(resp, SuccessResponse) and resp.body is not None:
-                return _json.loads(resp.body)
-        raise ValueError("No successful responses with a body found.")
-
-    def as_item_responses(self, item_id: Hashable) -> list[ResponseMessage | FailedRequestMessage]:
-        # Convert the responses to per-item responses
-        results: list[ResponseMessage | FailedRequestMessage] = []
-        for message in self.data:
-            if isinstance(message, SuccessResponse):
-                results.append(
-                    SuccessResponseItems(
-                        status_code=message.status_code, content=message.content, ids=[item_id], body=message.body
-                    )
-                )
-            elif isinstance(message, FailedResponse):
-                results.append(
-                    FailedResponseItems(
-                        status_code=message.status_code, ids=[item_id], body=message.body, error=message.error
-                    )
-                )
-            elif isinstance(message, FailedRequestMessage):
-                results.append(FailedRequestItems(ids=[item_id], error=message.error))
-            else:
-                results.append(message)
-        return results
-
-
-def _dump_body(body: dict[str, JsonVal]) -> str:
-    try:
-        return _json.dumps(body, allow_nan=False)
-    except ValueError as e:
-        # A lot of work to give a more human friendly error message when nans and infs are present:
-        msg = "Out of range float values are not JSON compliant"
-        if msg in str(e):  # exc. might e.g. contain an extra ": nan", depending on build (_json.make_encoder)
-            raise ValueError(f"{msg}. Make sure your data does not contain NaN(s) or +/- Inf!").with_traceback(
-                e.__traceback__
-            ) from None
-        raise
+    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 and not self.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 not self.disable_gzip and isinstance(data, bytes):
+                data = gzip.compress(data)
+        return data
+
+
+_BODY_SERIALIZER = TypeAdapter(dict[str, JsonValue])

cognite_toolkit/_cdf_tk/client/http_client/_item_classes.py

@@ -9,32 +9,32 @@ from cognite.client import global_config
 from pydantic import BaseModel, ConfigDict, Field, JsonValue
 
 from cognite_toolkit._cdf_tk.client._resource_base import RequestItem
-from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
+from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
     _BODY_SERIALIZER,
     BaseRequestMessage,
-    ErrorDetails2,
+    ErrorDetails,
 )
 from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIError
 from cognite_toolkit._cdf_tk.client.http_client._tracker import ItemsRequestTracker
 
 
-class ItemsResultMessage2(BaseModel):
+class ItemsResultMessage(BaseModel):
     ids: list[str]
 
 
-class ItemsFailedRequest2(ItemsResultMessage2):
+class ItemsFailedRequest(ItemsResultMessage):
     error_message: str
 
 
-class ItemsSuccessResponse2(ItemsResultMessage2):
+class ItemsSuccessResponse(ItemsResultMessage):
     status_code: int
     body: str
     content: bytes
 
 
-class ItemsFailedResponse2(ItemsResultMessage2):
+class ItemsFailedResponse(ItemsResultMessage):
     status_code: int
-    error: ErrorDetails2
+    error: ErrorDetails
     body: str
 
 
@@ -44,7 +44,7 @@ def _set_default_tracker(data: dict[str, Any]) -> ItemsRequestTracker:
     return data["tracker"]
 
 
-class ItemsRequest2(BaseRequestMessage):
+class ItemsRequest(BaseRequestMessage):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     items: Sequence[RequestItem]
     extra_body_fields: dict[str, JsonValue] | None = None
@@ -61,13 +61,13 @@ class ItemsRequest2(BaseRequestMessage):
             return gzip.compress(res)
         return res
 
-    def split(self, status_attempts: int) -> list["ItemsRequest2"]:
+    def split(self, status_attempts: int) -> list["ItemsRequest"]:
         """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] = []
+        messages: list[ItemsRequest] = []
         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
@@ -79,14 +79,14 @@ class ItemResponse(BaseModel):
     items: list[dict[str, JsonValue]]
 
 
-class ItemsResultList(UserList[ItemsResultMessage2]):
-    def __init__(self, collection: Sequence[ItemsResultMessage2] | None = None) -> None:
+class ItemsResultList(UserList[ItemsResultMessage]):
+    def __init__(self, collection: Sequence[ItemsResultMessage] | 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)]
+        failed_responses = [resp for resp in self.data if isinstance(resp, ItemsFailedResponse)]
+        failed_requests = [resp for resp in self.data if isinstance(resp, ItemsFailedRequest)]
         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)
@@ -104,7 +104,7 @@ class ItemsResultList(UserList[ItemsResultMessage2]):
             bool: True if there are any failed responses or requests, False otherwise.
         """
         for resp in self.data:
-            if isinstance(resp, ItemsFailedResponse2 | ItemsFailedRequest2):
+            if isinstance(resp, ItemsFailedResponse | ItemsFailedRequest):
                 return True
         return False
 
@@ -112,7 +112,7 @@ class ItemsResultList(UserList[ItemsResultMessage2]):
         """Get the items from all successful responses."""
         items: list[dict[str, JsonValue]] = []
         for resp in self.data:
-            if isinstance(resp, ItemsSuccessResponse2):
+            if isinstance(resp, ItemsSuccessResponse):
                 body_json = ItemResponse.model_validate_json(resp.body)
                 items.extend(body_json.items)
         return items

cognite_toolkit/_cdf_tk/client/resource_classes/filemetadata.py

@@ -1,4 +1,4 @@
-from typing import ClassVar, Literal
+from typing import Any, ClassVar, Literal
 
 from pydantic import Field, JsonValue
 
@@ -37,6 +37,12 @@ class FileMetadataRequest(FileMetadata, UpdatableRequestResource):
     # from response to request.
     instance_id: NodeReference | None = Field(default=None, exclude=True)
 
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        update = super().as_update(mode)
+        # Name cannot be updated.
+        update["update"].pop("name", None)
+        return update
+
 
 class FileMetadataResponse(FileMetadata, ResponseResource[FileMetadataRequest]):
     created_time: int

cognite_toolkit/_cdf_tk/client/resource_classes/project.py

@@ -0,0 +1,30 @@
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+
+class UserProfilesConfiguration(BaseModelObject):
+    enabled: bool
+
+
+class Claim(BaseModelObject):
+    claim_name: str
+
+
+class OidcConfiguration(BaseModelObject):
+    jwks_url: str
+    token_url: str | None = None
+    issuer: str
+    audience: str
+    skew_ms: int | None = None
+    access_claims: list[Claim]
+    scope_claims: list[Claim]
+    log_claims: list[Claim]
+    is_group_callback_enabled: bool | None = None
+    identity_provider_scope: str | None = None
+
+
+class OrganizationResponse(BaseModelObject):
+    name: str
+    url_name: str
+    organization: str
+    user_profiles_configuration: UserProfilesConfiguration
+    oidc_configuration: OidcConfiguration | None = None