cognite-neat 0.123.0__py3-none-any.whl → 0.123.2__py3-none-any.whl

cognite/neat/_version.py

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

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/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/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/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/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/plugins/__init__.py

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

cognite/neat/plugins/_issues.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+
+from cognite.neat.core._issues.errors import _NEAT_ERRORS_BY_NAME, 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"""
+
+    ...
+
+
+# Register the errors in the _NEAT_ERRORS_BY_NAME dictionary
+_NEAT_ERRORS_BY_NAME.update(
+    {
+        "PluginError": PluginError,
+        "PluginLoadingError": PluginLoadingError,
+        "PluginDuplicateError": PluginDuplicateError,
+    }
+)

cognite/neat/plugins/_manager.py

@@ -0,0 +1,103 @@
+"""Plugin manager for external plugins."""
+
+from importlib import metadata
+from typing import Any, ClassVar, TypeAlias, TypeVar, cast
+
+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
+
+# Generic type variable for plugin types
+T_NeatPlugin = TypeVar("T_NeatPlugin", bound=NeatPlugin)
+
+
+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) -> type[NeatPlugin]:
+        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[T_NeatPlugin]) -> type[T_NeatPlugin]:
+        """
+        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:
+            plugin_class = self._plugins[(name, type_)]
+            return cast(type[T_NeatPlugin], plugin_class)
+        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/plugins/data_model/importers/__init__.py

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

cognite/neat/plugins/data_model/importers/_base.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+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: str | Path | None, **kwargs: Any) -> BaseImporter:
+        """Return a configure plugin for data model import.
+
+        Args:
+            io (str | Path | None): 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/session/_base.py

@@ -30,6 +30,7 @@ from ._explore import ExploreAPI
 from ._fix import FixAPI
 from ._inspect import InspectAPI
 from ._mapping import MappingAPI
+from ._plugin import PluginAPI
 from ._prepare import PrepareAPI
 from ._read import ReadAPI
 from ._set import SetAPI
@@ -108,6 +109,7 @@ class NeatSession:
         self.subset = SubsetAPI(self._state)
         self.template = TemplateAPI(self._state)
         self._explore = ExploreAPI(self._state)
+        self.plugins = PluginAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):

cognite/neat/session/_experimental.py

@@ -23,3 +23,4 @@ class ExperimentalFlags:
     csv_read = ExperimentalFeatureWarning("csv_read")
     to_ontology = ExperimentalFeatureWarning("to_ontology")
     extension = ExperimentalFeatureWarning("extension")
+    plugin = ExperimentalFeatureWarning("plugin")

cognite/neat/session/_plugin.py

@@ -0,0 +1,67 @@
+import warnings
+from pathlib import Path
+from typing import Any
+
+from cognite.neat.core._issues._base import IssueList
+from cognite.neat.core._utils.reader._base import NeatReader
+from cognite.neat.plugins import get_plugin_manager
+from cognite.neat.plugins.data_model.importers._base import DataModelImporterPlugin
+from cognite.neat.session._experimental import ExperimentalFlags
+
+from ._state import SessionState
+from .exceptions import session_class_wrapper
+
+
+@session_class_wrapper
+class PluginAPI:
+    """Read from a data source into NeatSession graph store."""
+
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+
+        self.data_model = DataModelPlugins(self._state)
+
+
+@session_class_wrapper
+class DataModelPlugins:
+    """Read from a data source into NeatSession graph store."""
+
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+
+    def read(self, name: str, io: str | Path | None = None, **kwargs: Any) -> IssueList:
+        """Provides access to the external plugins for data model importing.
+
+        Args:
+            name (str): The name of format (e.g. Excel) plugin is handling.
+            io (str | Path | None): The input/output interface for the plugin.
+            **kwargs (Any): Additional keyword arguments for the plugin.
+
+        !!! note "kwargs"
+            Users must consult the documentation of the plugin to understand
+            what keyword arguments are supported.
+        """
+        warnings.filterwarnings("default")
+        ExperimentalFlags.plugin.warn()
+
+        # Some plugins may not support the io argument
+        if io:
+            reader = NeatReader.create(io)
+            path = reader.materialize_path()
+        else:
+            path = None
+
+        self._state._raise_exception_if_condition_not_met(
+            "Data Model Read",
+            empty_data_model_store_required=True,
+        )
+
+        plugin_manager = get_plugin_manager()
+        plugin = plugin_manager.get(name, DataModelImporterPlugin)
+
+        print(
+            f"You are using an external plugin {plugin.__name__}, which is not developed by the NEAT team."
+            "\nUse it at your own risk."
+        )
+
+        return self._state.data_model_import(plugin().configure(io=path, **kwargs))

cognite/neat/session/exceptions.py

@@ -5,7 +5,8 @@ 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.plugins._issues import PluginError
 from cognite.neat.session._experimental import ExperimentalFeatureWarning
 
 from ._collector import _COLLECTOR
@@ -50,6 +51,8 @@ def _session_method_wrapper(func: Callable, cls_name: str) -> Any:
             NeatImportError,
             NeatValueError,
             OxigraphStorageLockedError,
+            PluginError,
+            WillExceedLimitError,
         ) as e:
             print(f"{_ERROR_PREFIX} {escape(e.as_message())}")
         except ModuleNotFoundError as e:

{cognite_neat-0.123.0.dist-info → cognite_neat-0.123.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.0
+Version: 0.123.2
 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.0.dist-info → cognite_neat-0.123.2.dist-info}/RECORD

@@ -1,16 +1,16 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=qbLJI7CdcI5fE3rfND9BwqPVn9vL_dxL2ZEGKZdjavA,46
+cognite/neat/_version.py,sha256=HP2O0I_4JuG1TczHFazc53TQqD0Z8qh9R2SVWsXmlSQ,46
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
-cognite/neat/core/_constants.py,sha256=IaYEVDDHyQ2g3fys_8lqUtYaQSWw6PBkT4sgS9EwHl8,8113
+cognite/neat/core/_constants.py,sha256=Cc7p1QbpbzPSjlf-PB_Ow2pKRhWQL-K8VJma96HzU3A,8863
 cognite/neat/core/_shared.py,sha256=Ov59SWYboRRsncB_5V1ZC_BAoACfNLjo80vqE5Ru6wo,2325
 cognite/neat/core/_client/__init__.py,sha256=RQ7MwL8mwGqGHokRzsPqO3XStDzmI4-c12_gz1UPJ74,177
 cognite/neat/core/_client/_api_client.py,sha256=CqgG4kEArI9jiKAh82YrRZv_SzeMKA5guIZOvDg2R5I,860
 cognite/neat/core/_client/testing.py,sha256=rZGd-TFwNtfUqT8LV0u3FT0kHwNrjnvDNZU_Mcd5yx4,1329
 cognite/neat/core/_client/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_client/_api/data_modeling_loaders.py,sha256=YEZP0V_RXenzzFSxDzt4SbVnpzB4VP0fcI-Bab1VLw8,39815
-cognite/neat/core/_client/_api/neat_instances.py,sha256=2rSt4FVPvLA0lzwwOvCC9fJk87jTF1vudLO9Z6pgpk4,3354
+cognite/neat/core/_client/_api/neat_instances.py,sha256=8HcQO1sp8zjXdnRBRQ4yeQzt1O906HNSrDDCgrgTe8A,4805
 cognite/neat/core/_client/_api/schema.py,sha256=lbA8Cka_7K_RjmaxdeqkVkIwKPfWeDvpYvvEOGI07xo,6967
 cognite/neat/core/_client/_api/statistics.py,sha256=M0JpCHD6WMfggoe-HyXfeigwRCvZJjVF-xNB9CgB4UE,3796
 cognite/neat/core/_client/data_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -110,7 +110,7 @@ cognite/neat/core/_instances/extractors/_classic_cdf/_sequences.py,sha256=zwHM52
 cognite/neat/core/_instances/extractors/_classic_cdf/_timeseries.py,sha256=Py8MDcn82MJcsDPbeqDHMx4g2rQHmEOSHNe6gOi5gew,2044
 cognite/neat/core/_instances/loaders/__init__.py,sha256=qyOrKy0cJgYmgEuWVM-O1mpUemQE8EkfQYtJyEc8UVs,778
 cognite/neat/core/_instances/loaders/_base.py,sha256=jfik8xsdocMHVlodvgHpnDJfYdEjYuKdd0t7MGhzAHI,4337
-cognite/neat/core/_instances/loaders/_rdf2dms.py,sha256=PoNj77pxVoUpP7qxmMWf2nNul2PtlAlIFcVzUV2gyuE,29076
+cognite/neat/core/_instances/loaders/_rdf2dms.py,sha256=Nel9ZZ560XAfqNapHSr-P_sk5F_Yv4Ffk9slCfB7dG4,29355
 cognite/neat/core/_instances/loaders/_rdf_to_instance_space.py,sha256=qVxRzEUyhv8AGvAO8whJWPCZ-8BppEy0mk1Ux_8gOzY,11937
 cognite/neat/core/_instances/queries/__init__.py,sha256=W477LMyB4l6HIRbQhJoFgA_MUBwVCh2GBvtFeZu0AUA,53
 cognite/neat/core/_instances/queries/_base.py,sha256=APevHeeWQDEoOQ0MlBtVlPf9hbZukVkI5fOvt5oPJCE,543
@@ -128,9 +128,9 @@ cognite/neat/core/_issues/_base.py,sha256=iZcqGd5R6nnTBvVDGJ5VV67vQNvDuUzSQGtl2Z
 cognite/neat/core/_issues/_contextmanagers.py,sha256=5-QXVmfplt4S_k2csrQ2xuezOOuE5_FxSA9GVGVG1s4,1582
 cognite/neat/core/_issues/_factory.py,sha256=ifEzHZcvPyO0ZGJo8T8CE20F5L4yRzrrGPxl9d87oIs,2829
 cognite/neat/core/_issues/formatters.py,sha256=k2h_6wHW0ve52gXeuRoEcGwrxqqSe5sYFa_HycPiqW8,3323
-cognite/neat/core/_issues/errors/__init__.py,sha256=Qx70RN1C6JjYj16NtSz191DAUPzM5XxD6OqWSSM_uss,2368
+cognite/neat/core/_issues/errors/__init__.py,sha256=yIW5cntr-OA0BplqEtUJaaxTZpnwq-bAcTKhY-SSawc,2418
 cognite/neat/core/_issues/errors/_external.py,sha256=AaKwO5-AvX01d7Hd83vqYl1qNmMtgsmShmvyH8ioZAM,2354
-cognite/neat/core/_issues/errors/_general.py,sha256=R6TNBmvCsicqadC56ehiEc9lS18K5DMyK2_UXfv74uA,854
+cognite/neat/core/_issues/errors/_general.py,sha256=QEgTp_bvzGjmpRtr09Lj_SBeD9IVdql5_JmP02P7PfM,1391
 cognite/neat/core/_issues/errors/_properties.py,sha256=XkMLO4tkFX8vmGRixLdsmDAnlcipc78lypGccMYVAQk,2541
 cognite/neat/core/_issues/errors/_resources.py,sha256=lBK65tJZMhV3z3_xi8zJeo7Nt_agXsOklH_RPKQu28s,4002
 cognite/neat/core/_issues/errors/_wrapper.py,sha256=clhuSwUuHy-FQXQopFIQRY8c_NZM5u-QB9ncoc6Hrbo,2320
@@ -160,15 +160,22 @@ cognite/neat/core/_utils/upload.py,sha256=yR-BvvrWPh0XHoIGByXMEVi3JONzmc5xwXbmED
 cognite/neat/core/_utils/xml_.py,sha256=FQkq84u35MUsnKcL6nTMJ9ajtG9D5i1u4VBnhGqP2DQ,1710
 cognite/neat/core/_utils/reader/__init__.py,sha256=fPkrNB_9hLB7CyHTCFV_xEbIfOMqUQzNly5JN33-QfM,146
 cognite/neat/core/_utils/reader/_base.py,sha256=fRXxUWW8a3UFedeCLxDTDgFntWGlHaEGxmKLcITtiWE,5417
+cognite/neat/plugins/__init__.py,sha256=Q7r1FFbybOt71N9TjHjjk-1HguLRfHieLeiGVSG5HTY,75
+cognite/neat/plugins/_issues.py,sha256=jukeVjSs1DEzqtFuGRcIDbg7bNxZRxGPqnzumVRF-8c,940
+cognite/neat/plugins/_manager.py,sha256=_eJa5_3UGoLVacSQgbDrE0eWcopjeXxgbfSmvujeSiU,3979
+cognite/neat/plugins/data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/plugins/data_model/importers/__init__.py,sha256=d4UJNCFR1DXPY7lv5LdCW2hiStEhvXiu2g_bRSIp1y0,89
+cognite/neat/plugins/data_model/importers/_base.py,sha256=M9zXp7tEu1SfJZRAJAtLmqpssdFcoi2X-5e25q_n_h8,1034
 cognite/neat/session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/session/_base.py,sha256=DqujVyC19Jg8hGxnw9TfCeF3BYOFuauk4yTTuAsjJz4,12807
+cognite/neat/session/_base.py,sha256=vg8KgzpQxFnFCR4F0yRNSsRmrgYZQ77rW6eX4w7L9M4,12884
 cognite/neat/session/_collector.py,sha256=-icWXOT9YBjAOVZfpPtBx-D39kpRP2RaQKdPtcr7Xm8,4233
 cognite/neat/session/_drop.py,sha256=ipD8RS_ZebPNpeIkhC7yqSSeo7e57TXMRxrh5_6IRik,4239
-cognite/neat/session/_experimental.py,sha256=U_Wq3NWgnGaOJh5Fq8iO6HcYUhlG9RQIutT8e4LZL8o,1224
+cognite/neat/session/_experimental.py,sha256=0peZPZ9JpmzQE05wHbng2tWmPPLLTAVfWZEEUhdnI6o,1274
 cognite/neat/session/_explore.py,sha256=PLxpHDqBk5B0Q4a5tJKnF6KzL4heQ77b2qUETbf6iVQ,1599
 cognite/neat/session/_fix.py,sha256=oJRXuRI4f_HgLYHkjbtPAwHK0vSDUYd19hIZeFaE7rQ,919
 cognite/neat/session/_inspect.py,sha256=AESQd2SOidR_pDTFk5B_JdPnKZ5PNNskdAQBepH2Mv0,10175
 cognite/neat/session/_mapping.py,sha256=ItEXhXo_8V3069hktHMxdpBsLNeTck3gZBvhlm12Oxw,2895
+cognite/neat/session/_plugin.py,sha256=diFvZUFRvY037iVy_HxnIGMSfrauOpwYCSvFEPOzchQ,2282
 cognite/neat/session/_prepare.py,sha256=pskEVNgcnVJVRvYKk5xI55V89vKDO_kgjszj5flY8Zs,12778
 cognite/neat/session/_read.py,sha256=sKtSw7Ub--vR6wfEexNzzaEHb0MZCHj3kzCEnF5wjf0,35349
 cognite/neat/session/_set.py,sha256=PU4lKI-LGtKFVyvdtfZkk-zLw9e_rnFHzuV9IyrOrTM,4593
@@ -178,13 +185,13 @@ cognite/neat/session/_subset.py,sha256=p7n6WmL0gZlUbqpVBgyPncQ6uWn_pi7FDSixDFrm7
 cognite/neat/session/_template.py,sha256=NCgrrwLT98DpLYoo3Wybr_OUXrEXpsJZjrJ83KqfyWc,9908
 cognite/neat/session/_to.py,sha256=_R-UB3iEIQoa12kTD7tuSrRDdbySQXQg_mzbn5t-7bg,19399
 cognite/neat/session/_wizard.py,sha256=hARNNzD5Zfkk_V147rIjOLVvrFaqzXGXWhZuH1NJG3M,1486
-cognite/neat/session/exceptions.py,sha256=KJ7UUjmuGb_1O6FIamkwe4z0bCroAwn-AwX---hEudY,3341
+cognite/neat/session/exceptions.py,sha256=z5jxwfVTXDCCFZKTTYVIaksNKqb9CMa2tyIZgyNL3Us,3475
 cognite/neat/session/_state/README.md,sha256=o6N7EL98lgyWffw8IoEUf2KG5uSKveD5__TW45YzVjA,902
 cognite/neat/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvca6n48bu_bI,120
 cognite/neat/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/session/engine/_load.py,sha256=g52uYakQM03VqHt_RDHtpHso1-mFFifH5M4T2ScuH8A,5198
-cognite_neat-0.123.0.dist-info/METADATA,sha256=Vp8U9epVKAtAO58ylJPfHRW2VYeSCWLmNIXPPCaXNh0,9171
-cognite_neat-0.123.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.0.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.0.dist-info/RECORD,,
+cognite_neat-0.123.2.dist-info/METADATA,sha256=S0A0bAMepNWiOxj_BGAZL_nSetJnWlVdrgA8JOps3rI,9171
+cognite_neat-0.123.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.2.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.2.dist-info/RECORD,,