cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/statistics.py

@@ -1,72 +0,0 @@
-import itertools
-from typing import overload
-
-from cognite.client._api_client import APIClient
-from cognite.client._cognite_client import CogniteClient
-from cognite.client.config import ClientConfig
-from cognite.client.data_classes.data_modeling.ids import _load_space_identifier
-from cognite.client.utils.useful_types import SequenceNotStr
-
-from cognite_toolkit._cdf_tk.client.data_classes.statistics import (
-    ProjectStatsAndLimits,
-    SpaceInstanceCounts,
-    SpaceInstanceCountsList,
-)
-
-
-class StatisticsAPI(APIClient):
-    _RESOURCE_PATH = "/models/statistics"
-
-    def __init__(self, config: ClientConfig, api_version: str | None, cognite_client: CogniteClient) -> None:
-        # This is an alpha API, which requires a specific version.
-        super().__init__(config, "v1", cognite_client)
-        self._RETRIEVE_LIMIT = 100
-
-    def project(self) -> ProjectStatsAndLimits:
-        """`Retrieve project-wide usage data and limits
-
-        Returns the usage data and limits for a project's data modelling usage, including data model schemas
-        and graph instances
-
-        Returns:
-            ProjectStatsAndLimits: The requested statistics and limits
-
-        """
-        response_data = self._get(self._RESOURCE_PATH).json()
-        if "project" not in response_data:
-            response_data["project"] = self._cognite_client._config.project
-        return ProjectStatsAndLimits._load(response_data)
-
-    @overload
-    def list(self, space: str) -> SpaceInstanceCounts: ...
-
-    @overload
-    def list(self, space: SequenceNotStr[str] | None = None) -> SpaceInstanceCountsList: ...
-
-    def list(self, space: str | SequenceNotStr[str] | None = None) -> SpaceInstanceCounts | SpaceInstanceCountsList:
-        """`Retrieve usage data and limits per space
-
-        Args:
-            space (str | SequenceNotStr[str] | None): The space or spaces to retrieve statistics for.
-                If None, all spaces will be retrieved.
-
-        Returns:
-            SpaceInstanceCounts | SpaceInstanceCountsList: InstanceStatsPerSpace if a single space is given, else
-                InstanceStatsList (which is a list of InstanceStatsPerSpace)
-
-        """
-        if space is None:
-            return SpaceInstanceCountsList._load(self._get(self._RESOURCE_PATH + "/spaces").json()["items"])
-
-        is_single = isinstance(space, str)
-
-        ids = _load_space_identifier(space)
-        result = SpaceInstanceCountsList._load(
-            itertools.chain.from_iterable(
-                self._post(self._RESOURCE_PATH + "/spaces/byids", json={"items": chunk.as_dicts()}).json()["items"]
-                for chunk in ids.chunked(self._RETRIEVE_LIMIT)
-            )
-        )
-        if is_single:
-            return result[0]
-        return result

cognite_toolkit/_cdf_tk/client/data_classes/agent_tools.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from dataclasses import dataclass
-from typing import Any, Optional
-
-from cognite.client import CogniteClient
-from cognite.client.data_classes._base import (
-    CogniteResourceList,
-    InternalIdTransformerMixin,
-    WriteableCogniteResource,
-    WriteableCogniteResourceList,
-)
-
-
-@dataclass
-class AgentToolCore(WriteableCogniteResource["AgentToolWrite"], ABC):
-    """
-    Representation of an AI Agent Tool in CDF.
-
-    Args:
-        name (str): The name of the tool.
-        type (str): The type of the tool.
-        description (str): The description of the tool.
-        configuration (dict[str, Any] | None): The configuration of the tool.
-    """
-
-    name: str
-    type: str
-    description: str
-    configuration: Optional[dict[str, Any]] = None
-
-    def as_write(self) -> AgentToolWrite:
-        return AgentToolWrite(
-            name=self.name,
-            type=self.type,
-            description=self.description,
-            configuration=self.configuration,
-        )
-
-
-@dataclass
-class AgentTool(AgentToolCore):
-    """
-    Representation of an AI Agent Tool in CDF.
-    This is the read format of an agent tool.
-
-    Args:
-        name (str): The name of the tool.
-        type (str): The type of the tool.
-        description (str): The description of the tool.
-        configuration (dict[str, Any] | None): The configuration of the tool.
-    """
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: Optional[CogniteClient] = None) -> AgentTool:
-        return cls(
-            name=resource["name"],
-            type=resource["type"],
-            description=resource["description"],
-            configuration=resource.get("configuration"),
-        )
-
-
-@dataclass
-class AgentToolWrite(AgentToolCore):
-    """Representation of an AI Agent Tool in CDF.
-    This is the write format of an agent tool.
-
-    Args:
-        name (str): The name of the tool.
-        type (str): The type of the tool.
-        description (str): The description of the tool.
-        configuration (dict[str, Any] | None): The configuration of the tool.
-    """
-
-    pass
-
-
-class AgentToolWriteList(CogniteResourceList[AgentToolWrite]):
-    _RESOURCE = AgentToolWrite
-
-
-class AgentToolList(
-    WriteableCogniteResourceList[AgentToolWrite, AgentTool],
-    InternalIdTransformerMixin,
-):
-    _RESOURCE = AgentTool
-
-    def as_write(self) -> AgentToolWriteList:
-        """Returns this AgentToolWriteList instance"""
-        return AgentToolWriteList([item.as_write() for item in self.data], cognite_client=self._get_cognite_client())

cognite_toolkit/_cdf_tk/client/data_classes/agents.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC
-from dataclasses import dataclass
-from typing import Any, Optional
-
-from cognite.client import CogniteClient
-from cognite.client.data_classes._base import (
-    CogniteResourceList,
-    InternalIdTransformerMixin,
-    WriteableCogniteResource,
-    WriteableCogniteResourceList,
-)
-
-from cognite_toolkit._cdf_tk.client.data_classes.agent_tools import AgentTool
-
-
-@dataclass
-class AgentCore(WriteableCogniteResource["AgentWrite"], ABC):
-    """Representation of an AI Agent in CDF.
-
-    Args:
-        external_id (str): The external ID provided by the client. Must be unique for the resource type.
-        name (str): The name of the agent.
-        description (str | None): The description of the agent.
-        instructions (str | None): Instructions for the agent.
-        model (str | None): Name of the language model to use.
-        tools (list[AgentTool] | None): List of tools for the agent.
-
-    """
-
-    external_id: str
-    name: str
-    description: Optional[str] = None
-    instructions: Optional[str] = None
-    model: Optional[str] = None
-    tools: Optional[list[AgentTool]] = None
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        result = super().dump(camel_case=camel_case)
-        if self.tools:
-            result["tools"] = [item.dump(camel_case=camel_case) for item in self.tools]
-        if not self.instructions:
-            result["instructions"] = ""  # match API behavior
-        return result
-
-    def as_write(self) -> AgentWrite:
-        return AgentWrite(
-            external_id=self.external_id,
-            name=self.name,
-            description=self.description,
-            instructions=self.instructions,
-            model=self.model,
-            tools=self.tools,
-        )
-
-
-@dataclass
-class Agent(AgentCore):
-    """Representation of an AI Agent in CDF.
-    This is the read format of an agent.
-
-    Args:
-        external_id (str): The external ID provided by the client. Must be unique for the resource type.
-        name (str): The name of the agent.
-        description (str | None): The description of the agent.
-        instructions (str | None): Instructions for the agent.
-        model (str | None): Name of the language model to use.
-        tools (list[AgentTool] | None): List of tools for the agent.
-    """
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: Optional[CogniteClient] = None) -> Agent:
-        tools = (
-            [AgentTool._load(item) for item in resource.get("tools", [])]
-            if isinstance(resource.get("tools"), list)
-            else None
-        )
-
-        return cls(
-            external_id=resource["externalId"],
-            name=resource["name"],
-            description=resource.get("description"),
-            instructions=resource.get("instructions"),
-            model=resource.get("model"),
-            tools=tools,
-        )
-
-
-@dataclass
-class AgentWrite(AgentCore):
-    """Representation of an AI Agent in CDF.
-    This is the write format of an agent.
-
-    Args:
-        external_id (str): The external ID provided by the client. Must be unique for the resource type.
-        name (str): The name of the agent.
-        description (str | None): The description of the agent.
-        instructions (str | None): Instructions for the agent.
-        model (str | None): Name of the language model to use.
-        tools (list[AgentTool] | None): List of tools for the agent.
-
-    """
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: Optional[CogniteClient] = None) -> AgentWrite:
-        tools = (
-            [AgentTool._load(item) for item in resource.get("tools", [])]
-            if isinstance(resource.get("tools"), list)
-            else None
-        )
-
-        return cls(
-            external_id=resource["externalId"],
-            name=resource["name"],
-            description=resource.get("description", ""),
-            instructions=resource.get("instructions", ""),
-            model=resource.get("model"),
-            tools=tools,
-        )
-
-
-class AgentWriteList(CogniteResourceList[AgentWrite]):
-    _RESOURCE = AgentWrite
-
-
-class AgentList(
-    WriteableCogniteResourceList[AgentWrite, Agent],
-    InternalIdTransformerMixin,
-):
-    _RESOURCE = Agent
-
-    def as_write(self) -> AgentWriteList:
-        """Returns this AgentList as writeableinstance"""
-        return AgentWriteList([item.as_write() for item in self.data], cognite_client=self._get_cognite_client())

cognite_toolkit/_cdf_tk/client/data_classes/statistics.py

@@ -1,130 +0,0 @@
-import sys
-from dataclasses import dataclass
-from typing import Any
-
-from cognite.client import CogniteClient
-from cognite.client.data_classes._base import CogniteObject, CogniteResource, CogniteResourceList
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
-@dataclass
-class InstanceCounts(CogniteResource):
-    nodes: int
-    edges: int
-    soft_deleted_nodes: int
-    soft_deleted_edges: int
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        return cls(
-            nodes=resource["nodes"],
-            edges=resource["edges"],
-            soft_deleted_nodes=resource["softDeletedNodes"],
-            soft_deleted_edges=resource["softDeletedEdges"],
-        )
-
-
-@dataclass
-class SpaceInstanceCounts(InstanceCounts):
-    space: str
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        return cls(
-            space=resource["space"],
-            nodes=resource["nodes"],
-            edges=resource["edges"],
-            soft_deleted_nodes=resource["softDeletedNodes"],
-            soft_deleted_edges=resource["softDeletedEdges"],
-        )
-
-
-class SpaceInstanceCountsList(CogniteResourceList):
-    _RESOURCE = SpaceInstanceCounts
-
-
-@dataclass
-class CountLimitPair(CogniteObject):
-    count: int
-    limit: int
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        return cls(
-            count=resource["count"],
-            limit=resource["limit"],
-        )
-
-
-@dataclass
-class InstanceCountsLimits(InstanceCounts):
-    instances_limit: int
-    soft_deleted_instances_limit: int
-
-    @property
-    def instances(self) -> int:
-        return self.nodes + self.edges
-
-    @property
-    def soft_deleted_instances(self) -> int:
-        return self.soft_deleted_nodes + self.soft_deleted_edges
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        return cls(
-            nodes=resource["nodes"],
-            edges=resource["edges"],
-            soft_deleted_nodes=resource["softDeletedNodes"],
-            soft_deleted_edges=resource["softDeletedEdges"],
-            instances_limit=resource["instancesLimit"],
-            soft_deleted_instances_limit=resource["softDeletedInstancesLimit"],
-        )
-
-
-@dataclass
-class ProjectStatsAndLimits(CogniteResource):
-    project: str
-    spaces: CountLimitPair
-    containers: CountLimitPair
-    views: CountLimitPair
-    data_models: CountLimitPair
-    container_properties: CountLimitPair
-    instances: InstanceCountsLimits
-    concurrent_read_limit: int
-    concurrent_write_limit: int
-    concurrent_delete_limit: int
-
-    @classmethod
-    def _load(cls, data: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        return cls(
-            project=data["project"],
-            spaces=CountLimitPair._load(data["spaces"]),
-            containers=CountLimitPair._load(data["containers"]),
-            views=CountLimitPair._load(data["views"]),
-            data_models=CountLimitPair._load(data["dataModels"]),
-            container_properties=CountLimitPair._load(data["containerProperties"]),
-            instances=InstanceCountsLimits._load(data["instances"]),
-            concurrent_read_limit=data["concurrentReadLimit"],
-            concurrent_write_limit=data["concurrentWriteLimit"],
-            concurrent_delete_limit=data["concurrentDeleteLimit"],
-        )
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        return {
-            "project": self.project,
-            "spaces": self.spaces.dump(camel_case=camel_case),
-            "containers": self.containers.dump(camel_case=camel_case),
-            "views": self.views.dump(camel_case=camel_case),
-            "dataModels" if camel_case else "data_models": self.data_models.dump(camel_case=camel_case),
-            "containerProperties" if camel_case else "container_properties": self.container_properties.dump(
-                camel_case=camel_case
-            ),
-            "instances": self.instances.dump(camel_case=camel_case),
-            "concurrentReadLimit" if camel_case else "concurrent_read_limit": self.concurrent_read_limit,
-            "concurrentWriteLimit" if camel_case else "concurrent_write_limit": self.concurrent_write_limit,
-            "concurrentDeleteLimit" if camel_case else "concurrent_delete_limit": self.concurrent_delete_limit,
-        }