cognite-neat 0.123.0__tar.gz → 0.123.1__tar.gz

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.0
+Version: 0.123.1
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

cognite_neat-0.123.1/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.123.1"
+__engine__ = "^2.0.4"

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/core/_client/_api/neat_instances.py

@@ -7,6 +7,11 @@ from cognite.client.data_classes.filters import Filter
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite.neat.core._constants import DMS_INSTANCE_LIMIT_MARGIN
+from cognite.neat.core._issues import NeatIssue
+from cognite.neat.core._issues.errors import WillExceedLimitError
+from cognite.neat.core._issues.warnings import NeatValueWarning
+
 if TYPE_CHECKING:
     from cognite.neat.core._client._api_client import NeatClient
 
@@ -69,3 +74,28 @@ class NeatInstancesAPI:
             if (time.perf_counter() - last_limit_change) > 30.0 and body["limit"] < 1_000:
                 body["limit"] = min(int(body["limit"] * 1.5), 1_000)
                 last_limit_change = time.perf_counter()
+
+    def validate_cdf_project_capacity(self, total_instances: int) -> NeatIssue | None:
+        """Validates if the current project instance capacity can accommodate the given number of instances.
+
+        Args:
+            total_instances (int): The total number of instances to check against the project's capacity.
+
+        Returns:
+            NeatIssue | None: Returns a warning if the capacity is exceeded, otherwise None.
+
+        Raises:
+            WillExceedLimitError: If the total instances exceed the project's instance capacity.
+
+        """
+        try:
+            stats = self._client.instance_statistics.project()
+        except CogniteAPIError as e:
+            # This endpoint is not yet in alpha, it may change or not be available.
+            return NeatValueWarning(f"Cannot check project instance capacity. Endpoint not available: {e}")
+        instance_capacity = stats.instances.instances_limit - stats.instances.instances
+        if total_instances + DMS_INSTANCE_LIMIT_MARGIN > instance_capacity:
+            raise WillExceedLimitError(
+                "instances", total_instances, stats.project, instance_capacity, DMS_INSTANCE_LIMIT_MARGIN
+            )
+        return None

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/core/_constants.py

@@ -9,7 +9,6 @@ from rdflib import DC, DCTERMS, FOAF, OWL, RDF, RDFS, SH, SKOS, XSD, Namespace,
 from rdflib.namespace import DefinedNamespace
 
 from cognite import neat
-from cognite.neat.core._issues.errors._general import NeatValueError
 
 if TYPE_CHECKING:
     from cognite.neat.core._data_model.models.physical import PhysicalProperty
@@ -161,6 +160,14 @@ DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT = 100
 DMS_PRIMITIVE_LIST_DEFAULT_LIMIT = 1000
 DMS_CONTAINER_LIST_MAX_LIMIT = 2000
 
+# The number of instances that should be left as a margin when Neat writes to CDF through the DMS API.
+# This is currently set conservatively to 1 million. The reasoning for this is that there are CDF
+# applications such as Infield and Industrial Canvas that can write to the DMS API, as well as likely third-party
+# applications that can write to the DMS API. If Neat fills up the entire capacity, these type of data gathering
+# applications will experience data loss. The limit of 1 million is chosen such that it will trigger alarms in the
+# CDF projects, such that admins can take action to increase or clean up the capacity before it is too late.
+DMS_INSTANCE_LIMIT_MARGIN = 1_000_000
+
 _ASSET_ROOT_PROPERTY = {
     "connection": "direct",
     "container": "cdf_cdm:CogniteAsset",
@@ -211,6 +218,8 @@ def get_base_concepts(
         base_model: The base model to get the concepts for.
         total_concepts: The number of concepts to get. If None, all concepts are returned.
     """
+    # Local import to avoid circular dependency issues
+    from cognite.neat.core._issues.errors._general import NeatValueError
 
     if base_model == "CogniteCore":
         return [f"cdf_cdm:{concept}(version=v1)" for concept in COGNITE_CONCEPTS][:total_concepts]

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/core/_instances/loaders/_rdf2dms.py

@@ -159,6 +159,14 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         if self.neat_prefix_by_type_uri:
             self._lookup_identifier_by_uri()
 
+        if self._client:
+            validate_issue = self._client.instances.validate_cdf_project_capacity(
+                sum(it.instance_count for it in view_iterations)
+            )
+            if validate_issue:
+                yield validate_issue
+                return
+
         for it in view_iterations:
             view = it.view
             if view is None:

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/core/_issues/errors/__init__.py

@@ -12,7 +12,7 @@ from ._external import (
     NeatYamlError,
     OxigraphStorageLockedError,
 )
-from ._general import NeatImportError, NeatTypeError, NeatValueError, RegexViolationError
+from ._general import NeatImportError, NeatTypeError, NeatValueError, RegexViolationError, WillExceedLimitError
 from ._properties import (
     PropertyDefinitionDuplicatedError,
     PropertyDefinitionError,
@@ -82,6 +82,7 @@ __all__ = [
     "ReversedConnectionNotFeasibleError",
     "SpreadsheetError",
     "ViewValueError",
+    "WillExceedLimitError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/core/_issues/errors/_general.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Literal
 
 from cognite.neat.core._issues import NeatError
 
@@ -35,3 +36,16 @@ class NeatImportError(NeatError, ImportError):
 
     module: str
     neat_extra: str
+
+
+@dataclass(unsafe_hash=True)
+class WillExceedLimitError(NeatError, RuntimeError):
+    """Cannot write {resource_count} {resource_type} to project {project} as the current available capacity
+    is {available_capacity} {resource_type}. Neat requires a capacity of at least {margin} {resource_type} are
+    left for future writes, {available_capacity}-{resource_count} < {margin}."""
+
+    resource_type: Literal["instances"]
+    resource_count: int
+    project: str
+    available_capacity: int
+    margin: int

cognite_neat-0.123.1/cognite/neat/plugins/__init__.py

@@ -0,0 +1,3 @@
+from ._manager import get_plugin_manager
+
+__all__ = ["get_plugin_manager"]

cognite_neat-0.123.1/cognite/neat/plugins/_issues.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from cognite.neat.core._issues._base import NeatError
+
+
+@dataclass(unsafe_hash=True)
+class PluginError(NeatError, ImportError):
+    """No plugin of type '{plugin_type}' registered under name '{plugin_name}'"""
+
+    plugin_name: str
+    plugin_type: str
+
+
+@dataclass(unsafe_hash=True)
+class PluginLoadingError(PluginError):
+    """Unable to load plugin of type '{plugin_type}' registered under name '{plugin_name}' due to: {exception}"""
+
+    exception: str
+
+
+@dataclass(unsafe_hash=True)
+class PluginDuplicateError(PluginError):
+    """Plugin of type '{plugin_type}' registered for under name '{plugin_name}' already exists"""
+
+    ...

cognite_neat-0.123.1/cognite/neat/plugins/_manager.py

@@ -0,0 +1,99 @@
+"""Plugin manager for external plugins."""
+
+from importlib import metadata
+from typing import Any, ClassVar, TypeAlias
+
+from ._issues import PluginDuplicateError, PluginError, PluginLoadingError
+from .data_model.importers import DataModelImporterPlugin
+
+# Here we configure entry points where external plugins are going to be registered.
+plugins_entry_points = {
+    "cognite.neat.plugins.data_model.importers": DataModelImporterPlugin,
+}
+
+#: Type alias for all supported plugin types
+NeatPlugin: TypeAlias = DataModelImporterPlugin
+
+
+class Plugin:
+    """Plugin class for registering plugins registered via entry points (i.e. external plugins).
+
+    Args:
+        name (str): The name of format (e.g. Excel) or action (e.g. merge) plugin is handling.
+        type_ (type): The type of the plugin.
+        entry_point (EntryPoint): The entry point for the plugin.
+
+    !!! note "name uniqueness"
+        The name of the plugin must be lower case and unique across all plugins of the same kind.
+        If two plugins have the same name, the exception will be raised.
+    """
+
+    def __init__(self, name: str, type_: type[NeatPlugin], entry_point: metadata.EntryPoint):
+        self.name = name
+        self.type_ = type_
+        self.entry_point = entry_point
+
+    def load(self) -> Any:
+        try:
+            return self.entry_point.load()
+        except Exception as e:
+            raise PluginLoadingError(self.name, self.type_.__name__, str(e)) from e
+
+
+class PluginManager:
+    """Plugin manager for external plugins."""
+
+    _plugins_entry_points: ClassVar[dict[str, type[NeatPlugin]]] = {
+        "cognite.neat.plugins.data_model.importers": DataModelImporterPlugin,
+    }
+
+    def __init__(self, plugins: dict[tuple[str, type[NeatPlugin]], Any]) -> None:
+        self._plugins = plugins
+
+    def get(self, name: str, type_: type[NeatPlugin]) -> Any:
+        """
+        Returns desired plugin
+
+        Args:
+            name (str): The name of format (e.g. Excel) or action (e.g. merge) plugin is handling.
+            type_ (type): The type of the plugin.
+        """
+        try:
+            return self._plugins[(name, type_)]
+        except KeyError:
+            raise PluginError(plugin_name=name, plugin_type=type_.__name__) from None
+
+    @classmethod
+    def load_plugins(cls, entry_points: metadata.EntryPoints | None = None) -> "PluginManager":
+        """Load plugins from entry points and register them to the manager.
+        This method scans the provided entry points for plugins defined in the
+        `_plugins_entry_points` dictionary and registers them.
+
+        Args:
+            entry_points: Entry points to load plugins from. If None, uses the default entry points.
+        """
+        _plugins: dict[tuple[str, type[NeatPlugin]], Any] = {}
+
+        entry_points = entry_points or metadata.entry_points()
+        if hasattr(entry_points, "select"):
+            for group, type_ in cls._plugins_entry_points.items():
+                for entry_point in entry_points.select(group=group):
+                    # Check for duplicate plugins
+                    if (entry_point.name, type_) in _plugins:
+                        raise PluginDuplicateError(plugin_name=entry_point.name, plugin_type=type_.__name__)
+
+                    # Register the plugin
+                    _plugins[(entry_point.name, type_)] = Plugin(entry_point.name, type_, entry_point).load()
+
+        return cls(_plugins)
+
+
+_manager_instance: PluginManager | None = None
+
+
+def get_plugin_manager(force_reload: bool = False) -> PluginManager:
+    """Get or create a singleton PluginManager instance."""
+    global _manager_instance
+    if force_reload or _manager_instance is None:
+        _manager_instance = PluginManager.load_plugins()
+    return _manager_instance

cognite_neat-0.123.1/cognite/neat/plugins/data_model/importers/__init__.py

@@ -0,0 +1,5 @@
+from ._base import DataModelImporterPlugin
+
+__all__ = [
+    "DataModelImporterPlugin",
+]

cognite_neat-0.123.1/cognite/neat/plugins/data_model/importers/_base.py

@@ -0,0 +1,27 @@
+from typing import Any
+
+from cognite.neat.core._data_model.importers._base import BaseImporter
+
+
+class DataModelImporterPlugin:
+    """This class is used an interface for data model import plugins.
+    Any plugin that is used for importing data models should inherit from this class.
+    It is expected to implement the `configure` method which returns a configured importer.
+    """
+
+    def configure(self, io: Any, **kwargs: Any) -> BaseImporter:
+        """Return a configure plugin for data model import.
+
+        Args:
+            io (Any): The input/output interface for the plugin.
+            **kwargs (Any): Additional keyword arguments for configuration.
+
+        Returns:
+            BaseImporter: A configured instance of the BaseImporter.
+
+        !!! note "Returns"
+            The method must return an instance of `BaseImporter` or its subclasses
+            meaning it must implement the `BaseImporter` interface.
+        """
+
+        raise NotImplementedError()

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/cognite/neat/session/exceptions.py

@@ -5,7 +5,7 @@ from typing import Any, TypeVar
 
 from cognite.neat.core._issues.errors import CDFMissingClientError, NeatImportError
 from cognite.neat.core._issues.errors._external import OxigraphStorageLockedError
-from cognite.neat.core._issues.errors._general import NeatValueError
+from cognite.neat.core._issues.errors._general import NeatValueError, WillExceedLimitError
 from cognite.neat.session._experimental import ExperimentalFeatureWarning
 
 from ._collector import _COLLECTOR
@@ -50,6 +50,7 @@ def _session_method_wrapper(func: Callable, cls_name: str) -> Any:
             NeatImportError,
             NeatValueError,
             OxigraphStorageLockedError,
+            WillExceedLimitError,
         ) as e:
             print(f"{_ERROR_PREFIX} {escape(e.as_message())}")
         except ModuleNotFoundError as e:

cognite_neat-0.123.1/last_changelog_entry.md

@@ -0,0 +1,6 @@
+
+### Fixed
+
+- When writing instances (nodes and edges) to CDF using the
+`neat.to.cdf.instance()` method, Neat now checks that CDF will have at
+least free space for 500 000 instances after the writing is done.

cognite_neat-0.123.1/last_git_message.txt

@@ -0,0 +1,23 @@
+[NEAT-958, NEAT-811]  Check instance limit (#1222)
+
+# Description
+
+**Context**: We had incidents were neat has caused other applications to
+fail. This happen as the result of the user creating large amounts of
+instances in CDF using neat and filling up the instance capacity of the
+CDF project. This adds a fail-safe that stops the user from using neat
+to fill up to the instance limit in a CDF project and leave a margin
+such that other applications can continue to add new instances.
+
+## Bump
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## Changelog
+### Fixed
+
+- When writing instances (nodes and edges) to CDF using the
+`neat.to.cdf.instance()` method, Neat now checks that CDF will have at
+least free space for 500 000 instances after the writing is done.

cognite_neat-0.123.1/last_version.txt

@@ -0,0 +1 @@
+0.123.0

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.123.0"
+version = "0.123.1"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.123.1/tests/tests_unit/test_graph/test_loaders/test_rdf2dms.py

@@ -0,0 +1,107 @@
+import pytest
+from cognite.client.data_classes.data_modeling import ViewList
+
+from cognite.neat.core._client.data_classes.statistics import (
+    CountLimitPair,
+    InstanceCountsLimits,
+    ProjectStatsAndLimits,
+)
+from cognite.neat.core._client.testing import monkeypatch_neat_client
+from cognite.neat.core._constants import DMS_INSTANCE_LIMIT_MARGIN
+from cognite.neat.core._data_model.importers import SubclassInferenceImporter
+from cognite.neat.core._data_model.models import PhysicalDataModel
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.transformers._converters import (
+    ToCompliantEntities,
+)
+from cognite.neat.core._instances.loaders import DMSLoader, InstanceSpaceLoader
+from cognite.neat.core._issues import IssueList
+from cognite.neat.core._issues.errors import WillExceedLimitError
+from cognite.neat.core._store import NeatInstanceStore
+from tests.data import GraphData
+
+
+@pytest.fixture()
+def car_case() -> tuple[PhysicalDataModel, ConceptualDataModel, NeatInstanceStore]:
+    store = NeatInstanceStore.from_oxi_local_store()
+
+    for triple in GraphData.car.TRIPLES:
+        store.dataset.add(triple)
+    info_rules = (
+        SubclassInferenceImporter(
+            IssueList(),
+            store.dataset,
+            data_model_id=("sp_example_car", "CarModel", "1"),
+        )
+        .to_data_model()
+        .unverified_data_model
+    )
+
+    info_rules = ToCompliantEntities().transform(info_rules.as_verified_data_model())
+
+    dms_rules = GraphData.car.get_car_dms_rules()
+
+    # needs conversion to DMS rules as well
+    return dms_rules, info_rules, store
+
+
+class TestDMSLoader:
+    def test_load_car_example(self, car_case: tuple[PhysicalDataModel, ConceptualDataModel, NeatInstanceStore]) -> None:
+        dms_rules, info_rules, store = car_case
+
+        loader = DMSLoader(
+            dms_rules,
+            info_rules,
+            store,
+            InstanceSpaceLoader(instance_space=GraphData.car.INSTANCE_SPACE).space_by_instance_uri,
+        )
+
+        loaded = loader.load(stop_on_exception=True)
+
+        instances_expected = {inst.external_id: inst.dump() for inst in GraphData.car.INSTANCES}
+        instances_actual = {inst.external_id: inst.dump() for inst in loaded}
+
+        assert dict(sorted(instances_expected.items())) == dict(sorted(instances_actual.items()))
+
+    def test_load_car_example_instance_limit_reached(
+        self, car_case: tuple[PhysicalDataModel, ConceptualDataModel, NeatInstanceStore]
+    ) -> None:
+        dms_rules, info_rules, store = car_case
+
+        with monkeypatch_neat_client() as client:
+            client.iam.verify_capabilities.return_value = []
+            client.data_modeling.views.retrieve.return_value = ViewList(GraphData.car.CAR_MODEL.views)
+            client.instance_statistics.project.return_value = ProjectStatsAndLimits(
+                project="neat-project",
+                spaces=CountLimitPair(40, 100),
+                containers=CountLimitPair(100, 1000),
+                views=CountLimitPair(1000, 10_000),
+                data_models=CountLimitPair(10, 100),
+                instances=InstanceCountsLimits(
+                    nodes=4_000_000,
+                    edges=750_000,
+                    soft_deleted_nodes=0,
+                    soft_deleted_edges=0,
+                    soft_deleted_instances_limit=10_000_000,
+                    instances_limit=5_000_000,
+                ),
+                container_properties=CountLimitPair(5_000, 25_000),
+                concurrent_read_limit=8,
+                concurrent_write_limit=4,
+                concurrent_delete_limit=2,
+            )
+
+            loader = DMSLoader(
+                dms_rules,
+                info_rules,
+                store,
+                InstanceSpaceLoader(instance_space=GraphData.car.INSTANCE_SPACE).space_by_instance_uri,
+                client,
+            )
+
+        with pytest.raises(WillExceedLimitError) as excinfo:
+            _ = loader.load_into_cdf(client)
+
+        assert excinfo.value == WillExceedLimitError("instances", 6, "neat-project", 250_000, DMS_INSTANCE_LIMIT_MARGIN)

cognite_neat-0.123.1/tests/tests_unit/test_plugins.py

@@ -0,0 +1,110 @@
+from importlib.metadata import EntryPoint, EntryPoints
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from cognite.neat.core._data_model.importers._spreadsheet2data_model import ExcelImporter
+from cognite.neat.plugins._issues import (
+    PluginDuplicateError,
+    PluginLoadingError,
+)
+from cognite.neat.plugins._manager import PluginManager
+from cognite.neat.plugins.data_model.importers import DataModelImporterPlugin
+
+
+class ExcelDataModelImporterPlugin(DataModelImporterPlugin):
+    """Real ExcelDataModelImporter implementation for testing."""
+
+    def configure(self, io: Path, **kwargs: Any) -> ExcelImporter:
+        """
+        Configures Excel importer.
+
+        Args:
+            source (str): Path to the Excel file.
+        """
+
+        return ExcelImporter(filepath=io)
+
+
+@pytest.fixture
+def neat_plugin_entry_points():
+    """Create a mock entry point for testing."""
+
+    return EntryPoints(
+        [
+            EntryPoint(
+                name="excel",
+                group="cognite.neat.plugins.data_model.importers",
+                value="tests.tests_unit.test_plugins:ExcelDataModelImporterPlugin",
+            )
+        ]
+    )
+
+
+@pytest.fixture
+def none_neat_plugin_entry_points():
+    """Create a mock entry point for testing."""
+
+    return EntryPoints(
+        [EntryPoint(name="ox-turtle", group="rdf.plugins.parser", value="oxrdflib.parser:OxigraphTurtleParser")]
+    )
+
+
+@pytest.fixture
+def duplicated_neat_plugin():
+    """Create a mock entry point for testing."""
+
+    return EntryPoints(
+        [
+            EntryPoint(
+                name="excel",
+                group="cognite.neat.plugins.data_model.importers",
+                value="tests.tests_unit.test_plugins:ExcelDataModelImporterPlugin",
+            ),
+            EntryPoint(
+                name="excel",
+                group="cognite.neat.plugins.data_model.importers",
+                value="tests.test_plugins:ExcelDataModelImporterPlugin",
+            ),
+        ]
+    )
+
+
+@pytest.fixture
+def non_loadable_neat_plugin():
+    """Create a mock entry point for testing."""
+
+    return EntryPoints(
+        [
+            EntryPoint(
+                name="excel",
+                group="cognite.neat.plugins.data_model.importers",
+                value="tests.test_plugins:ExcelDataModelImporterPlugin",
+            )
+        ]
+    )
+
+
+def test_load_neat_plugin(neat_plugin_entry_points):
+    """Test ExternalPlugin initialization."""
+    manager = PluginManager.load_plugins(neat_plugin_entry_points)
+    assert len(manager._plugins) == 1
+
+
+def test_dont_load_none_neat_plugin(none_neat_plugin_entry_points):
+    """Test ExternalPlugin initialization."""
+    manager = PluginManager.load_plugins(none_neat_plugin_entry_points)
+    assert len(manager._plugins) == 0
+
+
+def test_duplicated_plugin_error(duplicated_neat_plugin):
+    """Test that registering a plugin with the same name raises an error."""
+    with pytest.raises(PluginDuplicateError):
+        PluginManager.load_plugins(duplicated_neat_plugin)
+
+
+def test_load_plugin_error(non_loadable_neat_plugin):
+    """Test that registering a plugin with the same name raises an error."""
+    with pytest.raises(PluginLoadingError):
+        PluginManager.load_plugins(non_loadable_neat_plugin)

{cognite_neat-0.123.0 → cognite_neat-0.123.1}/uv.lock

@@ -346,7 +346,7 @@ wheels = [
 
 [[package]]
 name = "cognite-neat"
-version = "0.123.0"
+version = "0.123.1"
 source = { editable = "." }
 dependencies = [
     { name = "backports-strenum", marker = "python_full_version < '3.11'" },

cognite_neat-0.123.0/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.123.0"
-__engine__ = "^2.0.4"

cognite_neat-0.123.0/last_changelog_entry.md

@@ -1,17 +0,0 @@
-
-### Added
-
-- Support for setting `cursorable` when specifying an index on container
-properties.
-
-### Fixed
-
-- Neat can now specify and maintains the order of multi-property order
-on indices. You do this with the syntax,
-`btree:multipPropertyIntdex(order=1)` in the Index column of the
-physical data model spreadsheet.
-
-### Changed
-
-- When setting an index on a property(ies) with a listable container,
-Neat uses an `InvertedIndex` instead of a `BTreeIndex`.

cognite_neat-0.123.0/last_git_message.txt

@@ -1,42 +0,0 @@
-[NEAT-1004] 🧑‍🏫 Support index cursorable (#1218)
-
-# Description
-
-Validation for this new syntax is introduced in #1230 
-
-**Context** The neat spreadsheet format is (with the exception of
-filters) a one-to-one with the DMS API for containers, views, and data
-models. We are currently missing setting `cursorable` on btree indexes.
-This PR introduces it.
-
-![image](https://github.com/user-attachments/assets/befa96f1-ba04-4334-8640-7ab5104c2bd9)
-
-
-Adds support for setting index. 
-* Introduce a `ContainerIndexEntity` to store the information. This is
-following the same pattern that we use for example Units.
-* Replace the `list[str]` with `list[ContainerIndexEntity]` for physical
-properties.
-## Bump
-
-- [ ] Patch
-- [x] Minor
-- [ ] Skip
-
-## Changelog
-### Added
-
-- Support for setting `cursorable` when specifying an index on container
-properties.
-
-### Fixed
-
-- Neat can now specify and maintains the order of multi-property order
-on indices. You do this with the syntax,
-`btree:multipPropertyIntdex(order=1)` in the Index column of the
-physical data model spreadsheet.
-
-### Changed
-
-- When setting an index on a property(ies) with a listable container,
-Neat uses an `InvertedIndex` instead of a `BTreeIndex`.

cognite_neat-0.123.0/last_version.txt

@@ -1 +0,0 @@
-0.122.3