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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.122.3
+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.122.3 → 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.122.3 → 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.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/_constants.py

@@ -42,6 +42,7 @@ class EntityTypes(StrEnum):
     version = "version"
     prefix = "prefix"
     space = "space"
+    container_index = "container_index"
 
 
 def get_reserved_words(

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/importers/_dms2data_model.py

@@ -47,6 +47,7 @@ from cognite.neat.core._data_model.models.data_types import DataType, Enum, Stri
 from cognite.neat.core._data_model.models.entities import (
     ConceptEntity,
     ContainerEntity,
+    ContainerIndexEntity,
     DMSNodeEntity,
     EdgeEntity,
     PhysicalUnknownEntity,
@@ -385,7 +386,9 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
             ),
             view=str(view_entity),
             view_property=prop_id,
-            index=self._get_index(prop, prop_id),
+            # MyPy fails to understand that list[ContainerIndexEntity] | None is valid even though
+            # the index expects str | list[ContainerIndexEntity | str] | None.
+            index=self._get_index(prop, prop_id),  # type: ignore[arg-type]
             constraint=self._get_constraint(prop, prop_id),
         )
 
@@ -548,14 +551,22 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
                 return str(default)
         return None
 
-    def _get_index(self, prop: ViewPropertyApply, prop_id: str) -> list[str] | None:
+    def _get_index(self, prop: ViewPropertyApply, prop_id: str) -> list[ContainerIndexEntity] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
         container = self._all_containers_by_id[prop.container]
-        index: list[str] = []
+        index: list[ContainerIndexEntity] = []
         for index_name, index_obj in (container.indexes or {}).items():
-            if isinstance(index_obj, BTreeIndex | InvertedIndex) and prop_id in index_obj.properties:
-                index.append(index_name)
+            if isinstance(index_obj, BTreeIndex) and prop_id in index_obj.properties:
+                order = None if len(index_obj.properties) == 1 else index_obj.properties.index(prop_id)
+                index.append(
+                    ContainerIndexEntity(
+                        prefix="btree", suffix=index_name, cursorable=index_obj.cursorable, order=order
+                    )
+                )
+            elif isinstance(index_obj, InvertedIndex) and prop_id in index_obj.properties:
+                order = None if len(index_obj.properties) == 1 else index_obj.properties.index(prop_id)
+                index.append(ContainerIndexEntity(prefix="inverted", suffix=index_name, order=order))
         return index or None
 
     def _get_constraint(self, prop: ViewPropertyApply, prop_id: str) -> list[str] | None:

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/entities/__init__.py

@@ -7,6 +7,7 @@ from ._single_value import (
     ConceptEntity,
     ConceptualEntity,
     ContainerEntity,
+    ContainerIndexEntity,
     DataModelEntity,
     DMSNodeEntity,
     DMSVersionedEntity,
@@ -33,6 +34,7 @@ __all__ = [
     "ConceptualEntity",
     "ContainerEntity",
     "ContainerEntityList",
+    "ContainerIndexEntity",
     "DMSFilter",
     "DMSNodeEntity",
     "DMSVersionedEntity",

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/entities/_single_value.py

@@ -172,8 +172,8 @@ class ConceptualEntity(BaseModel, extra="ignore"):
         extra: tuple[str, ...] = tuple(
             [
                 str(v or "")
-                for field_name in self.model_fields
-                if isinstance(v := getattr(self, field_name), str | None) and field_name not in {"prefix", "suffix"}
+                for field_name in self.model_fields.keys()
+                if (v := getattr(self, field_name)) and field_name not in {"prefix", "suffix"}
             ]
         )
         if isinstance(self.prefix, _UndefinedType):
@@ -225,8 +225,8 @@ class ConceptualEntity(BaseModel, extra="ignore"):
                     continue
                 if model_dump[key] == value:
                     to_delete.append(key)
-                elif isinstance(self, EdgeEntity):
-                    # Exception is edge entity, then, we remove all the defaults we can.
+                elif isinstance(self, EdgeEntity | ContainerIndexEntity):
+                    # Exception is edge and container index entities, then we remove all the defaults we can.
                     continue
                 else:
                     # Not all fields are default. We should not remove any of them.
@@ -549,3 +549,23 @@ class ReferenceEntity(ConceptEntity):
 
     def as_concept_entity(self) -> ConceptEntity:
         return ConceptEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
+
+
+class ContainerIndexEntity(PhysicalEntity[None]):
+    type_: ClassVar[EntityTypes] = EntityTypes.container_index
+    prefix: _UndefinedType | Literal["btree", "inverted"] = Undefined  # type: ignore[assignment]
+    suffix: str
+    order: int | None = Field(None, description="The order of the index. None indicates the value is not set.")
+    cursorable: bool | None = Field(
+        None, description="Whether the index is cursorable. None indicates the value is not set."
+    )
+    by_space: bool | None = Field(
+        None, alias="bySpace", description="Whether the index is by space. None indicates the value is not set."
+    )
+
+    def as_id(self) -> None:
+        return None
+
+    @classmethod
+    def from_id(cls, id: None) -> Self:
+        return cls(suffix="dummy")

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/entities/_types.py

@@ -10,6 +10,7 @@ from ._single_value import (
     AssetEntity,
     ConceptEntity,
     ContainerEntity,
+    ContainerIndexEntity,
     RelationshipEntity,
     ViewEntity,
 )
@@ -66,6 +67,16 @@ ContainerEntityList = Annotated[
     BeforeValidator(_split_str),
 ]
 
+ContainerIndexListType = Annotated[
+    list[ContainerIndexEntity],
+    BeforeValidator(_split_str),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
 ViewEntityList = Annotated[
     list[ViewEntity],
     BeforeValidator(_split_str),

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/physical/_exporter.py

@@ -4,7 +4,7 @@ from collections.abc import Collection, Hashable, Sequence
 from typing import Any, cast
 
 from cognite.client.data_classes import data_modeling as dm
-from cognite.client.data_classes.data_modeling.containers import BTreeIndex
+from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
 from cognite.client.data_classes.data_modeling.data_types import EnumValue as DMSEnumValue
 from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.views import (
@@ -29,6 +29,7 @@ from cognite.neat.core._data_model.models.data_types import DataType, Double, En
 from cognite.neat.core._data_model.models.entities import (
     ConceptEntity,
     ContainerEntity,
+    ContainerIndexEntity,
     DMSFilter,
     DMSNodeEntity,
     EdgeEntity,
@@ -36,6 +37,7 @@ from cognite.neat.core._data_model.models.entities import (
     NodeTypeFilter,
     PhysicalUnknownEntity,
     ReverseConnectionEntity,
+    Undefined,
     UnitEntity,
     ViewEntity,
 )
@@ -380,14 +382,25 @@ class _DMSExporter:
                 container.constraints = container.constraints or {}
                 container.constraints[constraint_name] = dm.UniquenessConstraint(properties=list(properties))
 
-            index_properties: dict[str, set[str]] = defaultdict(set)
+            index_properties: dict[tuple[str, bool], list[tuple[str, ContainerIndexEntity]]] = defaultdict(list)
             for prop in container_properties:
                 if prop.container_property is not None:
                     for index in prop.index or []:
-                        index_properties[index].add(prop.container_property)
-            for index_name, properties in index_properties.items():
+                        index_properties[(index.suffix, prop.is_list or False)].append((prop.container_property, index))
+            for (index_name, is_list), properties in index_properties.items():
                 container.indexes = container.indexes or {}
-                container.indexes[index_name] = BTreeIndex(properties=list(properties))
+                index_property_list = [prop_id for prop_id, _ in sorted(properties, key=lambda x: x[1].order or 0)]
+                index_entity = properties[0][1]
+                if index_entity.prefix == "inverted" or (index_entity.prefix is Undefined and is_list):
+                    container.indexes[index_name] = InvertedIndex(properties=index_property_list)
+                elif index_entity.prefix == "btree" or (index_entity.prefix is Undefined and not is_list):
+                    container.indexes[index_name] = BTreeIndex(
+                        properties=index_property_list, cursorable=index_entity.cursorable or False
+                    )
+                else:
+                    raise NeatValueError(
+                        f"Invalid index prefix {index_entity.prefix!r} in {container_id}.{index_entity.suffix!r}"
+                    )
 
         # We might drop containers we convert direct relations of list into multi-edge connections
         # which do not have a container.

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/physical/_unverified.py

@@ -21,6 +21,7 @@ from cognite.neat.core._data_model.models._base_unverified import (
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
     ContainerEntity,
+    ContainerIndexEntity,
     DMSNodeEntity,
     EdgeEntity,
     PhysicalUnknownEntity,
@@ -135,7 +136,7 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
     default: str | int | float | bool | dict | None = None
     container: str | None = None
     container_property: str | None = None
-    index: str | list[str] | None = None
+    index: str | list[str | ContainerIndexEntity] | ContainerIndexEntity | None = None
     constraint: str | list[str] | None = None
     neatId: str | URIRef | None = None
     conceptual: str | URIRef | None = None
@@ -167,6 +168,26 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
             if self.container
             else None
         )
+        if isinstance(self.index, ContainerIndexEntity) or (isinstance(self.index, str) and "," not in self.index):
+            output["Index"] = [ContainerIndexEntity.load(self.index)]
+        elif isinstance(self.index, str) and "," in self.index:
+            output["Index"] = [
+                ContainerIndexEntity.load(index.strip()) for index in self.index.split(",") if index.strip()
+            ]
+        elif isinstance(self.index, list):
+            index_list: list[ContainerIndexEntity | PhysicalUnknownEntity] = []
+            for index in self.index:
+                if isinstance(index, ContainerIndexEntity):
+                    index_list.append(index)
+                elif isinstance(index, str) and "," in index:
+                    index_list.extend(
+                        [ContainerIndexEntity.load(idx.strip()) for idx in index.split(",") if idx.strip()]
+                    )
+                elif isinstance(index, str):
+                    index_list.append(ContainerIndexEntity.load(index.strip()))
+                else:
+                    raise TypeError(f"Unexpected type for index: {type(index)}")
+            output["Index"] = index_list
         return output
 
     def referenced_view(self, default_space: str, default_version: str) -> ViewEntity:

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/physical/_validation.py

@@ -391,7 +391,9 @@ class PhysicalValidation:
                         "rows",
                     )
                 )
-            index_definitions = {",".join(prop.index) for _, prop in properties if prop.index is not None}
+            index_definitions = {
+                ",".join([index.suffix for index in prop.index]) for _, prop in properties if prop.index is not None
+            }
             if len(index_definitions) > 1:
                 errors.append(
                     PropertyDefinitionDuplicatedError[dm.ContainerId](

{cognite_neat-0.122.3 → cognite_neat-0.123.1}/cognite/neat/core/_data_model/models/physical/_verified.py

@@ -32,7 +32,6 @@ from cognite.neat.core._data_model.models._types import (
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
     ConceptualEntity,
-    ContainerEntityList,
     DMSNodeEntity,
     EdgeEntity,
     HasDataFilter,
@@ -44,6 +43,7 @@ from cognite.neat.core._data_model.models.entities import (
     ViewEntity,
     ViewEntityList,
 )
+from cognite.neat.core._data_model.models.entities._types import ContainerEntityList, ContainerIndexListType
 from cognite.neat.core._issues.errors import NeatValueError
 from cognite.neat.core._issues.warnings._general import NeatValueWarning
 
@@ -142,7 +142,7 @@ class PhysicalProperty(SheetRow):
         alias="Container Property",
         description="Specifies property in the container where the property is stored. Only applies to primitive type.",
     )
-    index: StrListType | None = Field(
+    index: ContainerIndexListType | None = Field(
         None,
         alias="Index",
         description="The names of the indexes (comma separated) that should be created for the property.",

{cognite_neat-0.122.3 → 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.122.3 → 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.122.3 → 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.122.3 → 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: