Storage statistics at space level

Thanks for reaching out to us. Yes, we have some functionality built into the Cognite Python SDK or via API call.

I’ll post a small snippet of the statistics.py that should be help. But I do see the ability to gather info on the number of concurrent requests. You can find the statistics.py in cognite/client/data_classes/data_modeling/statistics.py if you have the SDK.

@dataclass
class SpaceStatistics(CogniteResource):
    """Statistics for a space in the data modeling API.

    Attributes:
        space (str): The space name
        containers (int): Number of containers in the space.
        views (int): Number of views in the space.
        data_models (int): Number of data models in the space.
        nodes (int): Number of nodes in the space.
        edges (int): Number of edges in the space.
        soft_deleted_nodes (int): Number of soft-deleted nodes in the space.
        soft_deleted_edges (int): Number of soft-deleted edges in the space.

    """

    space: str
    containers: int
    views: int
    data_models: int
    edges: int
    soft_deleted_edges: int
    nodes: int
    soft_deleted_nodes: int

    @classmethod
    def _load(cls, resource: dict[str, Any]) -> Self:
        return cls(
            space=resource["space"],
            containers=resource["containers"],
            views=resource["views"],
            data_models=resource["dataModels"],
            edges=resource["edges"],
            soft_deleted_edges=resource["softDeletedEdges"],
            nodes=resource["nodes"],
            soft_deleted_nodes=resource["softDeletedNodes"],
        )


@dataclass
class ProjectStatistics(CogniteResource):
    """Statistics for a project in the data modeling API.

    Attributes:
        spaces (CountLimit): Usage and limits for spaces in the project
        containers (CountLimit): Usage and limits for containers in the project
        views (CountLimit): Usage and limits for views including all versions in the project
        data_models (CountLimit): Usage and limits for data models including all versions in the project
        container_properties (CountLimit): Usage and limits for sum of container properties in the project
        instances (InstanceStatistics): Usage and limits for number of instances in the project
        concurrent_read_limit (int): Maximum number of concurrent read operations allowed in the project
        concurrent_write_limit (int): Maximum number of concurrent write operations allowed in the project
        concurrent_delete_limit (int): Maximum number of concurrent delete operations allowed in the project
    """

    spaces: CountLimit
    containers: CountLimit
    views: CountLimit
    data_models: CountLimit
    container_properties: CountLimit
    instances: InstanceStatistics
    concurrent_read_limit: int
    concurrent_write_limit: int
    concurrent_delete_limit: int

    @property
    def project(self) -> str:
        try:
            return self._project
        except AttributeError:
            raise AttributeError("'project' not set on this ProjectStatistics, did you instantiate it yourself?")

    @project.setter
    def project(self, value: str) -> None:
        self._project = value

    @classmethod
    def _load(cls, resource: dict[str, Any]) -> Self:
        return cls(
            spaces=CountLimit._load(resource["spaces"]),
            containers=CountLimit._load(resource["containers"]),
            views=CountLimit._load(resource["views"]),
            data_models=CountLimit._load(resource["dataModels"]),
            container_properties=CountLimit._load(resource["containerProperties"]),
            instances=InstanceStatistics._load(resource["instances"]),
            concurrent_read_limit=resource["concurrentReadLimit"],
            concurrent_write_limit=resource["concurrentWriteLimit"],
            concurrent_delete_limit=resource["concurrentDeleteLimit"],
        )

Please feel free to reach out if you have additional questions. 

Regards,

Michael Bennett

Academy Engineer