cognite-neat 0.121.1__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.121.1"
+__version__ = "0.121.2"
 __engine__ = "^2.0.4"

cognite/neat/core/_client/_api/statistics.py

@@ -0,0 +1,91 @@
+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.neat.core._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
+
+        Examples:
+            Fetch project statistics (and limits) and check the current number of data models vs.
+            and how many more can be created:
+                >>> from cognite.neat.core._client import NeatClient
+                >>> client = NeatClient()
+                >>> stats = client.instance_statistics.project()
+                >>> num_dm = stats.data_models.current
+                >>> num_dm_left = stats.data_models.limit - num_dm
+        """
+        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)
+
+        Examples:
+            Fetch statistics for a single space:
+                >>> from cognite.neat.core._client import NeatClient
+                >>> client = NeatClient()
+                >>> res = client.instance_statistics.list("my-space")
+            Fetch statistics for multiple spaces:
+                >>> res = client.instance_statistics.list(
+                ...     ["my-space1", "my-space2"]
+                ... )
+            Fetch statistics for all spaces (ignores the 'space' argument):
+                >>> res = client.instance_statistics.list(return_all=True)
+        """
+        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/neat/core/_client/_api_client.py

@@ -5,6 +5,7 @@ from cognite.neat.core._utils.auth import _CLIENT_NAME
 from ._api.data_modeling_loaders import DataModelLoaderAPI
 from ._api.neat_instances import NeatInstancesAPI
 from ._api.schema import SchemaAPI
+from ._api.statistics import StatisticsAPI
 
 
 class NeatClient(CogniteClient):
@@ -17,3 +18,4 @@ class NeatClient(CogniteClient):
         self.loaders = DataModelLoaderAPI(self)
         self.schema = SchemaAPI(self)
         self.instances = NeatInstancesAPI(self)
+        self.instance_statistics = StatisticsAPI(self._config, self._config.api_subversion, self)

cognite/neat/core/_client/data_classes/statistics.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import CogniteObject, CogniteResource, CogniteResourceList
+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,
+        }

cognite/neat/core/_client/testing.py

@@ -1,6 +1,7 @@
 from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Any
+from unittest.mock import MagicMock
 
 from cognite.client.testing import CogniteClientMock
 
@@ -9,6 +10,7 @@ from cognite.neat.core._client._api_client import NeatClient
 from ._api.data_modeling_loaders import DataModelLoaderAPI
 from ._api.neat_instances import NeatInstancesAPI
 from ._api.schema import SchemaAPI
+from ._api.statistics import StatisticsAPI
 
 
 class NeatClientMock(CogniteClientMock):
@@ -22,6 +24,8 @@ class NeatClientMock(CogniteClientMock):
             super().__init__(*args, **kwargs)
             return
         super().__init__(*args, **kwargs)
+        self.instance_statistics = MagicMock(spec_set=StatisticsAPI)
+
         self.schema = SchemaAPI(self)
         self.loaders = DataModelLoaderAPI(self)
         self.instances = NeatInstancesAPI(self)

cognite/neat/core/_constants.py

@@ -12,7 +12,7 @@ from cognite import neat
 from cognite.neat.core._issues.errors._general import NeatValueError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._data_model.models.dms import DMSProperty
+    from cognite.neat.core._data_model.models.physical import PhysicalProperty
 
 
 def _is_in_notebook() -> bool:
@@ -104,9 +104,8 @@ COGNITE_CONCEPTS = (
 
 DMS_LISTABLE_PROPERTY_LIMIT = 1000
 
-EXAMPLE_RULES = PACKAGE_DIRECTORY / "_rules" / "examples"
-EXAMPLE_GRAPHS = PACKAGE_DIRECTORY / "_graph" / "examples"
-EXAMPLE_WORKFLOWS = PACKAGE_DIRECTORY / "_workflows" / "examples"
+EXAMPLE_RULES = PACKAGE_DIRECTORY / "core" / "_data_model" / "examples"
+EXAMPLE_GRAPHS = PACKAGE_DIRECTORY / "core" / "_instances" / "examples"
 
 DEFAULT_SPACE_URI = "http://purl.org/cognite/space/{space}#"
 SPACE_URI_PATTERN = re.compile(r"http://purl.org/cognite/space/(?P<space>[^#]+)#$")
@@ -196,11 +195,11 @@ _ASSET_PATH_PROPERTY = {
 BASE_MODEL = Literal["CogniteCore"]
 
 
-def get_asset_read_only_properties_with_connection() -> "list[DMSProperty]":
+def get_asset_read_only_properties_with_connection() -> "list[PhysicalProperty]":
     """Gets the asset read-only properties with connection, i.e. Root and Path."""
-    from cognite.neat.core._data_model.models.dms import DMSProperty
+    from cognite.neat.core._data_model.models.physical import PhysicalProperty
 
-    return [DMSProperty.model_validate(item) for item in (_ASSET_ROOT_PROPERTY, _ASSET_PATH_PROPERTY)]
+    return [PhysicalProperty.model_validate(item) for item in (_ASSET_ROOT_PROPERTY, _ASSET_PATH_PROPERTY)]
 
 
 def get_base_concepts(

cognite/neat/core/_data_model/_constants.py

@@ -15,9 +15,10 @@ class EntityTypes(StrEnum):
     predicate = "predicate"
     object = "object"
     class_ = "class"
+    concept = "concept"
     parent_class = "parent_class"
     property_ = "property"
-    dms_property = "dms_property"
+    physical_property = "physical_property"
     conceptual_property = "conceptual_property"
     object_property = "ObjectProperty"
     data_property = "DatatypeProperty"
@@ -43,9 +44,11 @@ class EntityTypes(StrEnum):
     space = "space"
 
 
-def get_reserved_words(key: Literal["class", "view", "property", "space"]) -> list[str]:
+def get_reserved_words(
+    key: Literal["concept", "view", "property", "space"],
+) -> list[str]:
     return {
-        "class": ["Class", "class"],
+        "concept": ["Concept", "concept"],
         "view": [
             "Query",
             "Mutation",
@@ -103,10 +106,14 @@ DATA_MODEL_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
 VIEW_ID_COMPLIANCE_REGEX = (
     rf"(?!^({'|'.join(get_reserved_words('view'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
-DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words('property'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+PHYSICAL_PROPERTY_ID_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words('property'))})$)"
+    r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+CONCEPT_ID_COMPLIANCE_REGEX = (
+    rf"(?!^({'|'.join(get_reserved_words('concept'))})$)"
+    r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 )
-CLASS_ID_COMPLIANCE_REGEX = rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 
 INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
@@ -139,15 +146,15 @@ class _Patterns:
         return re.compile(VIEW_ID_COMPLIANCE_REGEX)
 
     @cached_property
-    def dms_property_id_compliance(self) -> re.Pattern[str]:
-        return re.compile(DMS_PROPERTY_ID_COMPLIANCE_REGEX)
+    def physical_property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(PHYSICAL_PROPERTY_ID_COMPLIANCE_REGEX)
 
     @cached_property
-    def class_id_compliance(self) -> re.Pattern[str]:
-        return re.compile(CLASS_ID_COMPLIANCE_REGEX)
+    def concept_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(CONCEPT_ID_COMPLIANCE_REGEX)
 
     @cached_property
-    def information_property_id_compliance(self) -> re.Pattern[str]:
+    def conceptual_property_id_compliance(self) -> re.Pattern[str]:
         return re.compile(INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX)
 
     @cached_property
@@ -158,11 +165,11 @@ class _Patterns:
         self,
         entity: EntityTypes,
     ) -> re.Pattern:
-        if entity == EntityTypes.class_:
-            return self.class_id_compliance
+        if entity == EntityTypes.concept:
+            return self.concept_id_compliance
 
         elif entity == EntityTypes.conceptual_property:
-            return self.information_property_id_compliance
+            return self.conceptual_property_id_compliance
 
         elif entity == EntityTypes.view:
             return self.view_id_compliance
@@ -171,8 +178,8 @@ class _Patterns:
         elif entity == EntityTypes.container:
             return self.view_id_compliance
 
-        elif entity == EntityTypes.dms_property:
-            return self.dms_property_id_compliance
+        elif entity == EntityTypes.physical_property:
+            return self.physical_property_id_compliance
 
         elif entity == EntityTypes.version:
             return self.version_compliance

cognite/neat/core/_data_model/_shared.py

@@ -3,27 +3,36 @@ from typing import Generic, TypeAlias, TypeVar
 
 from cognite.neat.core._data_model.models import (
     ConceptualDataModel,
-    DMSRules,
+    PhysicalDataModel,
 )
 from cognite.neat.core._data_model.models.conceptual._unverified import (
     UnverifiedConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.dms._rules_input import DMSInputRules
+from cognite.neat.core._data_model.models.physical._unverified import (
+    UnverifiedPhysicalDataModel,
+)
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 
-VerifiedRules: TypeAlias = ConceptualDataModel | DMSRules
+VerifiedDataModel: TypeAlias = ConceptualDataModel | PhysicalDataModel
 
-T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
-InputRules: TypeAlias = DMSInputRules | UnverifiedConceptualDataModel
-T_InputRules = TypeVar("T_InputRules", bound=InputRules)
+T_VerifiedDataModel = TypeVar("T_VerifiedDataModel", bound=VerifiedDataModel)
+UnverifiedDataModel: TypeAlias = UnverifiedPhysicalDataModel | UnverifiedConceptualDataModel
+T_UnverifiedDataModel = TypeVar("T_UnverifiedDataModel", bound=UnverifiedDataModel)
 
 
 @dataclass
-class ReadRules(Generic[T_InputRules]):
-    """This represents a rules that has been read."""
+class ImportedDataModel(Generic[T_UnverifiedDataModel]):
+    """This class is used to store results of data model import from a source prior to
+    verification and validation.
+
+    Attributes:
+        unverified_data_model: The unverified data model.
+        context: The context of the import, including warnings, errors and any other
+                 relevant information.
+    """
 
-    rules: T_InputRules | None
-    read_context: dict[str, SpreadsheetRead]
+    unverified_data_model: T_UnverifiedDataModel | None
+    context: dict[str, SpreadsheetRead]
 
     @classmethod
     def display_type_name(cls) -> str:
@@ -31,13 +40,20 @@ class ReadRules(Generic[T_InputRules]):
 
     @property
     def display_name(self) -> str:
-        if self.rules is None:
-            return "FailedRead"
-        return self.rules.display_name
+        if self.unverified_data_model is None:
+            return "Failed to load data model"
+        return self.unverified_data_model.display_name
 
 
-ReadInputRules: TypeAlias = ReadRules[DMSInputRules] | ReadRules[UnverifiedConceptualDataModel]
-T_ReadInputRules = TypeVar("T_ReadInputRules", bound=ReadInputRules)
+ImportedUnverifiedDataModel: TypeAlias = (
+    ImportedDataModel[UnverifiedPhysicalDataModel] | ImportedDataModel[UnverifiedConceptualDataModel]
+)
+T_ImportedUnverifiedDataModel = TypeVar("T_ImportedUnverifiedDataModel", bound=ImportedUnverifiedDataModel)
 
-Rules: TypeAlias = ConceptualDataModel | DMSRules | ReadRules[DMSInputRules] | ReadRules[UnverifiedConceptualDataModel]
-T_Rules = TypeVar("T_Rules", bound=Rules)
+DataModel: TypeAlias = (
+    ConceptualDataModel
+    | PhysicalDataModel
+    | ImportedDataModel[UnverifiedPhysicalDataModel]
+    | ImportedDataModel[UnverifiedConceptualDataModel]
+)
+T_DataModel = TypeVar("T_DataModel", bound=DataModel)

cognite/neat/core/_data_model/analysis/__init__.py

@@ -1,3 +1,3 @@
-from ._base import RulesAnalysis
+from ._base import DataModelAnalysis
 
-__all__ = ["RulesAnalysis"]
+__all__ = ["DataModelAnalysis"]