cognite-neat 0.123.30__py3-none-any.whl → 0.123.31__py3-none-any.whl

cognite/neat/_data_model/models/dms/__init__.py

@@ -0,0 +1,10 @@
+from ._base import Resource, WriteableResource
+from ._space import Space, SpaceRequest, SpaceResponse
+
+__all__ = [
+    "Resource",
+    "Space",
+    "SpaceRequest",
+    "SpaceResponse",
+    "WriteableResource",
+]

cognite/neat/_data_model/models/dms/_base.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+
+class BaseModelObject(BaseModel, alias_generator=to_camel, extra="ignore"):
+    """Base class for all object. This includes resources and nested objects."""
+
+    ...
+
+
+class Resource(BaseModelObject):
+    """Base class for all data modeling resources."""
+
+    ...
+
+
+T_Resource = TypeVar("T_Resource", bound=Resource)
+
+
+class WriteableResource(Generic[T_Resource], Resource, ABC):
+    @abstractmethod
+    def as_request(self) -> T_Resource:
+        """Convert the response model to a request model by removing read-only fields."""
+        raise NotImplementedError()

cognite/neat/_data_model/models/dms/_constants.py

@@ -0,0 +1,2 @@
+SPACE_FORMAT_PATTERN = r"[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$"
+FORBIDDEN_SPACES = frozenset(["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"])

cognite/neat/_data_model/models/dms/_space.py

@@ -0,0 +1,44 @@
+from abc import ABC
+
+from pydantic import Field, field_validator
+
+from cognite.neat.core._utils.text import humanize_collection
+
+from ._base import WriteableResource
+from ._constants import FORBIDDEN_SPACES, SPACE_FORMAT_PATTERN
+
+
+class Space(WriteableResource["SpaceRequest"], ABC):
+    space: str = Field(
+        description="The Space identifier (id).",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    name: str | None = Field(None, description="Name of the space.", max_length=1024)
+    description: str | None = Field(None, description="The description of the space.", max_length=255)
+
+    @field_validator("space")
+    def check_forbidden_space_value(cls, val: str) -> str:
+        """Check the space name not present in forbidden set"""
+        if val in FORBIDDEN_SPACES:
+            raise ValueError(f"{val!r} is a reserved space. Reserved Spaces: {humanize_collection(FORBIDDEN_SPACES)}")
+        return val
+
+    def as_request(self) -> "SpaceRequest":
+        return SpaceRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class SpaceResponse(Space):
+    created_time: int = Field(
+        description="When the space was created. The number of milliseconds since 00:00:00 Thursday, 1 January 1970, "
+        "Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    last_updated_time: int = Field(
+        description="When the space was last updated. The number of milliseconds since 00:00:00 Thursday, "
+        "1 January 1970, Coordinated Universal Time (UTC), minus leap seconds."
+    )
+    is_global: bool = Field(description="Whether the space is a global space.")
+
+
+class SpaceRequest(Space): ...

cognite/neat/_utils/auxiliary.py

@@ -0,0 +1,32 @@
+import inspect
+from abc import ABC
+from typing import TypeVar
+
+T_Cls = TypeVar("T_Cls")
+
+
+def get_concrete_subclasses(base_cls: type[T_Cls], exclude_direct_abc_inheritance: bool = True) -> list[type[T_Cls]]:
+    """
+    Returns a list of all concrete subclasses of the given base class.
+    Args:
+        base_cls (type[T_Cls]): The base class to find subclasses for.
+        exclude_direct_abc_inheritance (bool): If True, excludes classes that directly inherit from `abc.ABC`.
+            This is used as a marker to filter out intermediate base classes. Defaults to True.
+    Returns:
+        list[type[T_Cls]]: A list of concrete subclasses of the base class.
+    """
+    to_check = [base_cls]
+    subclasses: list[type[T_Cls]] = []
+    seen: set[type[T_Cls]] = {base_cls}
+    while to_check:
+        current_cls = to_check.pop()
+        for subclass in current_cls.__subclasses__():
+            if subclass in seen:
+                continue
+            if (not inspect.isabstract(subclass)) and (
+                not exclude_direct_abc_inheritance or ABC not in subclass.__bases__
+            ):
+                subclasses.append(subclass)
+            seen.add(subclass)
+            to_check.append(subclass)
+    return subclasses

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.30"
+__version__ = "0.123.31"
 __engine__ = "^2.0.4"

cognite/neat/session/_base.py

@@ -33,7 +33,6 @@ from ._mapping import MappingAPI
 from ._plugin import PluginAPI
 from ._prepare import PrepareAPI
 from ._read import ReadAPI
-from ._session._data_model import DataModelAPI
 from ._set import SetAPI
 from ._show import ShowAPI
 from ._state import SessionState
@@ -116,9 +115,6 @@ class NeatSession:
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 
-        # new API for data model operations
-        self.data_model = DataModelAPI(self._state)
-
     def _select_most_performant_store(self) -> Literal["memory", "oxigraph"]:
         """Select the most performant store based on the current environment."""
 

{cognite_neat-0.123.30.dist-info → cognite_neat-0.123.31.dist-info}/METADATA

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

@@ -1,6 +1,15 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=Umq3xx0HZoXDYrJ16jkCraj5gi3lRvqf-wxtIkntgvg,47
+cognite/neat/_version.py,sha256=c-BbCQozGLPXIz0KlrtSttiQDSYohkj9MbUXKI693Pc,47
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/models/dms/__init__.py,sha256=LwuPR4zOPinhT89mN0XEB38d5deWmLbGFs_RvENVQlc,212
+cognite/neat/_data_model/models/dms/_base.py,sha256=R8SP3Zi9daTBqewYKGjuNEkrWc-j91f-6t34CN-9YJ0,719
+cognite/neat/_data_model/models/dms/_constants.py,sha256=TpnOZ5Q1O_r2H5Ez3sAvaCH2s5DbnUm0qeRC-K1iPAQ,164
+cognite/neat/_data_model/models/dms/_space.py,sha256=W5tRG3GIcxRK9RBkpWWtZWdaqUZPiKq-NMOwPuHjj9o,1677
+cognite/neat/_data_model/models/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_utils/auxiliary.py,sha256=szvIrFRfBSZ_CpF24z5I1ustJohdvGZjdi_7TFB6Ltc,1236
 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=wIpGOzZAKS2vhshXR1K51cbcsgq2TlvZaZ3zw91CU9I,9054
@@ -170,7 +179,7 @@ cognite/neat/plugins/data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 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=yxAItY6663wcmlrwxmzWkJorrrrm9oahpYOP-5RGwvQ,13081
+cognite/neat/session/_base.py,sha256=6P63Kq4JJSi3S1CpcVLiG-dfKsN9Ml3o5GqZXjcLVvo,12937
 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=0peZPZ9JpmzQE05wHbng2tWmPPLLTAVfWZEEUhdnI6o,1274
@@ -189,18 +198,12 @@ cognite/neat/session/_template.py,sha256=NCgrrwLT98DpLYoo3Wybr_OUXrEXpsJZjrJ83Kq
 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=z5jxwfVTXDCCFZKTTYVIaksNKqb9CMa2tyIZgyNL3Us,3475
-cognite/neat/session/_session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/session/_session/_data_model/__init__.py,sha256=417QF6wm3r-bLTmhYGXL_5XnEFShCklLCoGg3YBOIqY,62
-cognite/neat/session/_session/_data_model/_read.py,sha256=B_mVOt_9uKzG5vbrZG2Uf5D0FQGjcCDEdfAhIp2veUI,7902
-cognite/neat/session/_session/_data_model/_routes.py,sha256=FtCMbqvji2KqAPDkZ4yXXp_Fuf6mSFTpNRyVfWOMzFE,1773
-cognite/neat/session/_session/_data_model/_show.py,sha256=yX4BTIeBzcCcllfJvGm8g4qy13heFmcJtpXPixI8T2o,5835
-cognite/neat/session/_session/_data_model/_write.py,sha256=qpb15cnGLknkDkxKndpdvLxhsmJ4XkXfuFD4-CDw0qE,14612
 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.30.dist-info/METADATA,sha256=girPGuZI_KaMxUsiBAAyFdVBLXuFrHyPMJP8dDX0u6M,9166
-cognite_neat-0.123.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.30.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.30.dist-info/RECORD,,
+cognite_neat-0.123.31.dist-info/METADATA,sha256=fDMu0gS-R0DVtoE1eFJcyXsniWkamkN_jvc5kSTFx_8,9166
+cognite_neat-0.123.31.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.31.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.31.dist-info/RECORD,,

cognite/neat/session/_session/_data_model/__init__.py

@@ -1,3 +0,0 @@
-from ._routes import DataModelAPI
-
-__all__ = ["DataModelAPI"]

cognite/neat/session/_session/_data_model/_read.py

@@ -1,193 +0,0 @@
-from typing import Any, Literal, cast
-from zipfile import Path
-
-from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
-
-from cognite.neat.core._client._api_client import NeatClient
-from cognite.neat.core._data_model import importers
-from cognite.neat.core._data_model.importers._base import BaseImporter
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._issues.errors._general import NeatValueError
-from cognite.neat.core._issues.warnings._general import MissingCogniteClientWarning
-from cognite.neat.core._utils.reader._base import NeatReader
-from cognite.neat.plugins._manager import get_plugin_manager
-from cognite.neat.plugins.data_model.importers._base import DataModelImporterPlugin
-from cognite.neat.session._state import SessionState
-from cognite.neat.session.exceptions import NeatSessionError, session_class_wrapper
-
-InternalReaderName = Literal["excel", "cdf", "ontology", "yaml"]
-
-
-@session_class_wrapper
-class ReadAPI:
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-
-    def __call__(self, name: str, io: str | Path | DataModelIdentifier, **kwargs: Any) -> IssueList:
-        """Provides access to internal data model readers and external data model
-        reader plugins.
-
-        Args:
-            name (str): The name of format (e.g. Excel) reader is handling.
-            io (str | Path | | DataModelIdentifier | None): The input/output interface for the reader.
-            **kwargs (Any): Additional keyword arguments for the reader.
-
-        !!! note "io"
-            The `io` parameter can be a file path, sting, or a DataModelIdentifier
-            depending on the reader's requirements.
-
-        !!! note "kwargs"
-            Users must consult the documentation of the reader to understand
-            what keyword arguments are supported.
-        """
-
-        # Clean the input name once before matching.
-        clean_name: InternalReaderName | str = name.strip().lower()
-
-        # The match statement cleanly handles each case.
-        match clean_name:
-            case "excel":
-                return self.excel(cast(str | Path, io), **kwargs)
-
-            case "cdf":
-                return self.cdf(cast(DataModelIdentifier, io))
-
-            case "ontology":
-                return self.ontology(cast(str | Path, io))
-
-            case "yaml":
-                return self.yaml(cast(str | Path, io), **kwargs)
-
-            case _:  # The wildcard '_' acts as the default 'else' case.
-                return self._plugin(name, cast(str | Path, io), **kwargs)
-
-    def _plugin(self, name: str, io: str | Path, **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.
-        """
-
-        # Some plugins may not support the io argument
-        reader = NeatReader.create(io)
-        path = reader.materialize_path()
-
-        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))
-
-    def cdf(self, io: DataModelIdentifier) -> IssueList:
-        """Reads a Data Model from CDF to the knowledge graph.
-
-        Args:
-            io: Tuple of strings with the id of a CDF Data Model.
-            Notation as follows (<name_of_space>, <name_of_data_model>, <data_model_version>)
-
-        Example:
-            ```python
-            neat.read.cdf.data_model(("example_data_model_space", "EXAMPLE_DATA_MODEL", "v1"))
-            ```
-        """
-
-        data_model_id = DataModelId.load(io)
-
-        if not data_model_id.version:
-            raise NeatSessionError("Data model version is required to read a data model.")
-
-        self._state._raise_exception_if_condition_not_met(
-            "Read data model from CDF",
-            empty_data_model_store_required=True,
-            client_required=True,
-        )
-
-        return self._state.data_model_import(
-            importers.DMSImporter.from_data_model_id(cast(NeatClient, self._state.client), data_model_id)
-        )
-
-    def excel(self, io: str | Path, *, enable_manual_edit: bool = False) -> IssueList:
-        """Reads a Neat Excel Data Model to the data model store.
-        The data model spreadsheets may contain conceptual or physical data model definitions.
-
-            Args:
-                io: file path to the Excel sheet
-                enable_manual_edit: If True, the user will be able to re-import data model
-                    which where edit outside of NeatSession
-        """
-        reader = NeatReader.create(io)
-        path = reader.materialize_path()
-
-        self._state._raise_exception_if_condition_not_met(
-            "Read Excel Data Model",
-            empty_data_model_store_required=not enable_manual_edit,
-        )
-
-        return self._state.data_model_import(importers.ExcelImporter(path), enable_manual_edit)
-
-    def ontology(self, io: str | Path) -> IssueList:
-        """Reads an OWL ontology source into NeatSession.
-
-        Args:
-            io: file path or url to the OWL file
-        """
-
-        self._state._raise_exception_if_condition_not_met(
-            "Read Ontology",
-            empty_data_model_store_required=True,
-        )
-
-        reader = NeatReader.create(io)
-        importer = importers.OWLImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
-        return self._state.data_model_import(importer)
-
-    def yaml(self, io: str | Path, *, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
-        """Reads a yaml with either neat data mode, or several toolkit yaml files to
-        import Data Model(s) into NeatSession.
-
-        Args:
-            io: File path to the Yaml file in the case of "neat" yaml, or path to a zip folder or directory with several
-                Yaml files in the case of "toolkit".
-            format: The format of the yaml file(s). Can be either "neat" or "toolkit".
-
-        Example:
-            ```python
-            neat.read.yaml("path_to_toolkit_yamls")
-            ```
-        """
-        self._state._raise_exception_if_condition_not_met(
-            "Read YAML data model",
-            empty_data_model_store_required=True,
-        )
-        reader = NeatReader.create(io)
-        path = reader.materialize_path()
-        importer: BaseImporter
-        if format == "neat":
-            importer = importers.DictImporter.from_yaml_file(path, source_name=f"{reader!s}")
-        elif format == "toolkit":
-            dms_importer = importers.DMSImporter.from_path(path, self._state.client)
-            if dms_importer.issue_list.has_warning_type(MissingCogniteClientWarning):
-                raise NeatSessionError(
-                    "No client provided. You are referencing Cognite containers in your data model, "
-                    "NEAT needs a client to lookup the container definitions. "
-                    "Please set the client in the session, NeatSession(client=client)."
-                )
-            importer = dms_importer
-        else:
-            raise NeatValueError(f"Unsupported YAML format: {format}")
-        return self._state.data_model_import(importer)

cognite/neat/session/_session/_data_model/_routes.py

@@ -1,45 +0,0 @@
-from cognite.neat.core._data_model.models.conceptual._verified import ConceptualDataModel
-from cognite.neat.core._data_model.models.physical._verified import PhysicalDataModel
-from cognite.neat.session._session._data_model._read import ReadAPI
-from cognite.neat.session._session._data_model._show import ShowAPI
-from cognite.neat.session._session._data_model._write import WriteAPI
-from cognite.neat.session._state import SessionState
-from cognite.neat.session.exceptions import session_class_wrapper
-
-
-@session_class_wrapper
-class DataModelAPI:
-    """API for managing data models in NEAT session."""
-
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-        self.read = ReadAPI(state)
-        self.write = WriteAPI(state)
-        self.show = ShowAPI(state)
-
-    @property
-    def physical(self) -> PhysicalDataModel | None:
-        """Access to the physical data model level."""
-        return self._state.data_model_store.try_get_last_physical_data_model
-
-    @property
-    def conceptual(self) -> ConceptualDataModel | None:
-        """Access to the conceptual data model level."""
-        return self._state.data_model_store.try_get_last_conceptual_data_model
-
-    def _repr_html_(self) -> str:
-        if self._state.data_model_store.empty:
-            return (
-                "<strong>No data model</strong>. Get started by reading data model with the <em>.read</em> attribute."
-            )
-
-        output = []
-
-        if self._state.data_model_store.provenance:
-            if self.physical:
-                html = self.physical._repr_html_()
-            if self.conceptual:
-                html = self.conceptual._repr_html_()
-            output.append(f"<H2>Data Model</H2><br />{html}")
-
-        return "<br />".join(output)

cognite/neat/session/_session/_data_model/_show.py

@@ -1,147 +0,0 @@
-from typing import Any
-
-import networkx as nx
-from IPython.display import HTML, display
-from pyvis.network import Network as PyVisNetwork  # type: ignore
-
-from cognite.neat.core._constants import IN_NOTEBOOK, IN_PYODIDE
-from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
-from cognite.neat.core._utils.io_ import to_directory_compatible
-from cognite.neat.core._utils.rdf_ import uri_display_name
-from cognite.neat.session._show import _generate_hex_color_per_type
-from cognite.neat.session._state import SessionState
-from cognite.neat.session.exceptions import NeatSessionError, session_class_wrapper
-
-
-@session_class_wrapper
-class ShowAPI:
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-
-    def __call__(self) -> Any:
-        """Generates a visualization of the data model without implements."""
-        if self._state.data_model_store.empty:
-            raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a data model.")
-
-        last_target = self._state.data_model_store.provenance[-1].target_entity
-        data_model = last_target.physical or last_target.conceptual
-        analysis = DataModelAnalysis(physical=last_target.physical, conceptual=last_target.conceptual)
-
-        if last_target.physical is not None:
-            di_graph = analysis._physical_di_graph(format="data-model")
-        else:
-            di_graph = analysis._conceptual_di_graph(format="data-model")
-
-        identifier = to_directory_compatible(str(data_model.metadata.identifier))
-        name = f"{identifier}.html"
-        return self._generate_visualization(di_graph, name)
-
-    def implements(self) -> Any:
-        """Generates a visualization of implements of the data model concepts, showing
-        the inheritance between the concepts in the data model."""
-        if self._state.data_model_store.empty:
-            raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a data model.")
-
-        last_target = self._state.data_model_store.provenance[-1].target_entity
-        data_model = last_target.physical or last_target.conceptual
-        analysis = DataModelAnalysis(physical=last_target.physical, conceptual=last_target.conceptual)
-
-        if last_target.physical is not None:
-            di_graph = analysis._physical_di_graph(format="implements")
-        else:
-            di_graph = analysis._conceptual_di_graph(format="implements")
-        identifier = to_directory_compatible(str(data_model.metadata.identifier))
-        name = f"{identifier}_implements.html"
-        return self._generate_visualization(di_graph, name)
-
-    def provenance(self) -> Any:
-        if not self._state.data_model_store.provenance:
-            raise NeatSessionError("No data model available. Try using [bold].read[/bold] to load data model.")
-
-        di_graph = self._generate_provenance_di_graph()
-        unique_hash = self._state.data_model_store.calculate_provenance_hash(shorten=True)
-        return self._generate_visualization(di_graph, name=f"data_model_provenance_{unique_hash}.html")
-
-    def _generate_visualization(self, di_graph: nx.DiGraph, name: str) -> Any:
-        if not IN_NOTEBOOK:
-            raise NeatSessionError("Visualization is only available in Jupyter notebooks!")
-
-        net = PyVisNetwork(
-            notebook=IN_NOTEBOOK,
-            cdn_resources="remote",
-            directed=True,
-            height="750px",
-            width="100%",
-            select_menu=IN_NOTEBOOK,
-        )
-
-        # Change the plotting layout
-        net.repulsion(
-            node_distance=100,
-            central_gravity=0.3,
-            spring_length=200,
-            spring_strength=0.05,
-            damping=0.09,
-        )
-
-        net.from_nx(di_graph)
-        if IN_PYODIDE:
-            net.write_html(name)
-            return display(HTML(name))
-
-        else:
-            return net.show(name)
-
-    def _generate_provenance_di_graph(self) -> nx.DiGraph:
-        di_graph = nx.DiGraph()
-        hex_colored_types = _generate_hex_color_per_type(["Agent", "Entity", "Activity", "Export", "Pruned"])
-
-        for change in self._state.data_model_store.provenance:
-            source = uri_display_name(change.source_entity.id_)
-            target = uri_display_name(change.target_entity.id_)
-            agent = uri_display_name(change.agent.id_)
-
-            di_graph.add_node(
-                source,
-                label=source,
-                type="Entity",
-                title="Entity",
-                color=hex_colored_types["Entity"],
-            )
-
-            di_graph.add_node(
-                target,
-                label=target,
-                type="Entity",
-                title="Entity",
-                color=hex_colored_types["Entity"],
-            )
-
-            di_graph.add_node(
-                agent,
-                label=agent,
-                type="Agent",
-                title="Agent",
-                color=hex_colored_types["Agent"],
-            )
-
-            di_graph.add_edge(source, agent, label="used", color="grey")
-            di_graph.add_edge(agent, target, label="generated", color="grey")
-
-        for (
-            source_id,
-            exports,
-        ) in self._state.data_model_store.exports_by_source_entity_id.items():
-            source_shorten = uri_display_name(source_id)
-            for export in exports:
-                export_id = uri_display_name(export.target_entity.id_)
-                di_graph.add_node(
-                    export_id,
-                    label=export_id,
-                    type="Export",
-                    title="Export",
-                    color=hex_colored_types["Export"],
-                )
-                di_graph.add_edge(source_shorten, export_id, label="exported", color="grey")
-
-        return di_graph

cognite/neat/session/_session/_data_model/_write.py

@@ -1,335 +0,0 @@
-import warnings
-from pathlib import Path
-from typing import Any, Literal, cast, overload
-
-from cognite.client.data_classes.data_modeling import DataModelIdentifier
-
-from cognite.neat.core._client._api_client import NeatClient
-from cognite.neat.core._constants import COGNITE_MODELS
-from cognite.neat.core._data_model import exporters
-from cognite.neat.core._data_model._shared import VerifiedDataModel
-from cognite.neat.core._data_model.importers._dms2data_model import DMSImporter
-from cognite.neat.core._data_model.models.conceptual._verified import ConceptualDataModel
-from cognite.neat.core._data_model.models.physical._verified import PhysicalDataModel, PhysicalMetadata
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._issues._contextmanagers import catch_issues
-from cognite.neat.core._utils.auxiliary import filter_kwargs_by_method
-from cognite.neat.core._utils.reader._base import NeatReader
-from cognite.neat.core._utils.upload import UploadResultList
-from cognite.neat.session._state import SessionState
-from cognite.neat.session.exceptions import NeatSessionError, session_class_wrapper
-
-InternalWriterName = Literal["excel", "ontology", "shacl", "cdf", "yaml"]
-
-
-@session_class_wrapper
-class WriteAPI:
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-
-    def __call__(
-        self, name: str, io: str | Path | None = None, **kwargs: Any
-    ) -> str | UploadResultList | IssueList | None:
-        """Provides access to the writers for exporting data models to different formats.
-
-        Args:
-            name (str): The name of format (e.g. Excel) writer is handling.
-            io (str | Path | None): The input/output interface for the writer.
-            **kwargs (Any): Additional keyword arguments for the writer.
-
-        !!! note "kwargs"
-            Users must consult the documentation of the writer
-            to understand what keyword arguments are supported.
-        """
-
-        # Clean the input name once before matching.
-        clean_name: InternalWriterName | str = name.strip().lower()
-
-        match clean_name:
-            case "excel":
-                if io is None:
-                    raise NeatSessionError("'io' parameter is required for Excel format.")
-                return self.excel(cast(str | Path, io), **filter_kwargs_by_method(kwargs, self.excel))
-            case "cdf":
-                return self.cdf(**filter_kwargs_by_method(kwargs, self.cdf))
-            case "yaml":
-                return self.yaml(io, **filter_kwargs_by_method(kwargs, self.yaml))
-            case "ontology":
-                if io is None:
-                    raise NeatSessionError("'io' parameter is required for ontology format.")
-                self.ontology(cast(str | Path, io))
-                return None
-            case "shacl":
-                if io is None:
-                    raise NeatSessionError("'io' parameter is required for SHACL format.")
-                self.shacl(cast(str | Path, io))
-                return None
-            case _:
-                raise NeatSessionError(
-                    f"Unsupported data model writer: {name}. "
-                    "Please use one of the following: 'excel', 'cdf', 'yaml', 'ontology', 'shacl'."
-                )
-
-    def excel(
-        self,
-        io: str | Path,
-        *,
-        include_reference: bool | DataModelIdentifier = True,
-        include_properties: Literal["same-space", "all"] = "all",
-        add_empty_rows: bool = False,
-    ) -> IssueList | None:
-        """Export the verified data model to Excel.
-
-        Args:
-            io: The file path or file-like object to write the Excel file to.
-            include_reference: If True, the reference data model will be included. Defaults to True.
-                Note that this only applies if you have created the data model using the
-                create.enterprise_model(...), create.solution_model(), or create.data_product_model() methods.
-                You can also provide a DataModelIdentifier directly, which will be read from CDF
-            include_properties: The properties to include in the Excel file. Defaults to "all".
-                - "same-space": Only properties that are in the same space as the data model will be included.
-            add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
-
-        Example:
-            Export conceptual data model to an Excel file
-            ```python
-            conceptual_dm_file_name = "conceptual_data_model.xlsx"
-            neat.data_model.write.excel(conceptual_dm_file_name)
-            ```
-
-        Example:
-            Read CogniteCore model, convert it to an enterprise model, and export it to an excel file
-            ```python
-            client = CogniteClient()
-            neat = NeatSession(client)
-
-            neat.data_model.read.cdf(("cdf_cdm", "CogniteCore", "v1"))
-            neat.data_model.create.enterprise_model(
-                data_model_id=("sp_doctrino_space", "ExtensionCore", "v1"),
-                org_name="MyOrg",
-            )
-            physical_dm_file_name = "physical_dm.xlsx"
-            neat.data_model.write.excel(physical_dm_file_name, include_reference=True)
-            ```
-
-        Example:
-            Read the data model ("my_space", "ISA95Model", "v5") and export it to an excel file with the
-            CogniteCore model in the reference sheets.
-            ```python
-            client = CogniteClient()
-            neat = NeatSession(client)
-
-            neat.data_model.read.cdf(("my_space", "ISA95Model", "v5"))
-            physical_dm_file_name = "physical_dm.xlsx"
-            neat.data_model.write.excel(physical_dm_file_name, include_reference=("cdf_cdm", "CogniteCore", "v1"))
-        """
-        reference_data_model_with_prefix: tuple[VerifiedDataModel, str] | None = None
-        include_properties = include_properties.strip().lower()
-        if include_properties not in ["same-space", "all"]:
-            raise NeatSessionError(
-                f"Invalid include_properties value: '{include_properties}'. Must be 'same-space' or 'all'."
-            )
-
-        if include_reference is not False:
-            if include_reference is True and self._state.last_reference is not None:
-                ref_data_model: ConceptualDataModel | PhysicalDataModel | None = self._state.last_reference
-            elif include_reference is True:
-                ref_data_model = None
-            else:
-                if not self._state.client:
-                    raise NeatSessionError("No client provided!")
-                ref_data_model = None
-                with catch_issues() as issues:
-                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_data_model()
-                    if ref_read.unverified_data_model is not None:
-                        ref_data_model = ref_read.unverified_data_model.as_verified_data_model()
-                if ref_data_model is None or issues.has_errors:
-                    issues.action = f"Read {include_reference}"
-                    return issues
-            if ref_data_model is not None:
-                prefix = "Ref"
-                if (
-                    isinstance(ref_data_model.metadata, PhysicalMetadata)
-                    and ref_data_model.metadata.as_data_model_id() in COGNITE_MODELS
-                ):
-                    prefix = "CDM"
-                reference_data_model_with_prefix = ref_data_model, prefix
-
-        exporter = exporters.ExcelExporter(
-            styling="maximal",
-            reference_data_model_with_prefix=reference_data_model_with_prefix,
-            add_empty_rows=add_empty_rows,
-            include_properties=cast(Literal["same-space", "all"], include_properties),
-        )
-        self._state.data_model_store.export_to_file(exporter, NeatReader.create(io).materialize_path())
-        return None
-
-    def cdf(
-        self,
-        *,
-        existing: Literal["fail", "skip", "update", "force", "recreate"] = "update",
-        dry_run: bool = False,
-        drop_data: bool = False,
-    ) -> UploadResultList:
-        """Export the verified DMS data model to CDF.
-
-        Args:
-            existing: What to do if the component already exists. Defaults to "update".
-                See the note below for more information about the options.
-            dry_run: If True, no changes will be made to CDF. Defaults to False.
-            drop_data: If existing is 'force' or 'recreate' and the operation will lead to data loss,
-                the component will be skipped unless drop_data is True. Defaults to False.
-                Note this only applies to spaces and containers if they contain data.
-
-        !!! note "Data Model creation modes"
-            - "fail": If any component already exists, the export will fail.
-            - "skip": If any component already exists, it will be skipped.
-            - "update": If any component already exists, it will be updated. For data models, views, and containers
-                this means combining the existing and new component. Fo example, for data models the new
-                views will be added to the existing views.
-            - "force": If any component already exists, and the update fails, it will be deleted and recreated.
-            - "recreate": All components will be deleted and recreated. The exception is spaces, which will be updated.
-
-        """
-
-        self._state._raise_exception_if_condition_not_met(
-            "Export DMS data model to CDF",
-            client_required=True,
-        )
-
-        exporter = exporters.DMSExporter(existing=existing, drop_data=drop_data)
-
-        result = self._state.data_model_store.export_to_cdf(exporter, cast(NeatClient, self._state.client), dry_run)
-        print("You can inspect the details with the .inspect.outcome.data_model(...) method.")
-        return result
-
-    @overload
-    def yaml(
-        self,
-        io: None,
-        *,
-        format: Literal["neat", "toolkit"] = "neat",
-        skip_system_spaces: bool = True,
-    ) -> str: ...
-
-    @overload
-    def yaml(
-        self,
-        io: str | Path,
-        *,
-        format: Literal["neat", "toolkit"] = "neat",
-        skip_system_spaces: bool = True,
-    ) -> None: ...
-
-    def yaml(
-        self,
-        io: str | Path | None = None,
-        *,
-        format: Literal["neat", "toolkit"] = "neat",
-        skip_system_spaces: bool = True,
-    ) -> str | None:
-        """Export the verified data model to YAML.
-
-        Args:
-            io: The file path or file-like object to write the YAML file to. Defaults to None.
-            format: The format of the YAML file. Defaults to "neat".
-            skip_system_spaces: If True, system spaces will be skipped. Defaults to True.
-
-        !!! note "YAML formats"
-            - "neat": This is the format Neat uses to store the data model.
-            - "toolkit": This is the format used by Cognite Toolkit, that matches the CDF API.
-
-        Returns:
-            str | None: If io is None, the YAML string will be returned. Otherwise, None will be returned.
-
-        Example:
-            Export to yaml file in the case of "neat" format
-            ```python
-            your_yaml_file_name = "neat_dm.yaml"
-            neat.data_model.write.yaml(your_yaml_file_name, format="neat")
-            ```
-
-        Example:
-            Export yaml files as a zip folder in the case of "toolkit" format
-            ```python
-            your_zip_folder_name = "toolkit_data_model_files.zip"
-            neat.data_model.write.yaml(your_zip_folder_name, format="toolkit")
-            ```
-
-        Example:
-            Export yaml files to a folder in the case of "toolkit" format
-            ```python
-            your_folder_name = "my_project/data_model_files"
-            neat.data_model.write.yaml(your_folder_name, format="toolkit")
-            ```
-        """
-
-        if format == "neat":
-            exporter = exporters.YAMLExporter()
-            if io is None:
-                return self._state.data_model_store.export(exporter)
-
-            self._state.data_model_store.export_to_file(exporter, NeatReader.create(io).materialize_path())
-        elif format == "toolkit":
-            if io is None:
-                raise NeatSessionError(
-                    "Please provide a zip file or directory path to write the YAML files to."
-                    "This is required for the 'toolkit' format."
-                )
-            user_path = NeatReader.create(io).materialize_path()
-            if user_path.suffix == "" and not user_path.exists():
-                user_path.mkdir(parents=True)
-            self._state.data_model_store.export_to_file(
-                exporters.DMSExporter(remove_cdf_spaces=skip_system_spaces), user_path
-            )
-        else:
-            raise NeatSessionError("Please provide a valid format. 'neat' or 'toolkit'")
-
-        return None
-
-    def ontology(self, io: str | Path) -> None:
-        """Write out data model as OWL ontology.
-
-        Args:
-            io: The file path to file-like object to write the session to.
-
-        Example:
-            Export the session to a file
-            ```python
-            ontology_file_name = "neat_session.ttl"
-            neat.data_model.write.ontology(ontology_file_name)
-            ```
-        """
-
-        filepath = self._prepare_ttl_filepath(io)
-        exporter = exporters.OWLExporter()
-        self._state.data_model_store.export_to_file(exporter, filepath)
-        return None
-
-    def shacl(self, io: str | Path) -> None:
-        """Write out data model as SHACL shapes.
-
-        Args:
-            io: The file path to file-like object to write the session to.
-
-        Example:
-            Export the session to a file
-            ```python
-            shacl_file_name = "neat_session.shacl.ttl"
-            neat.data_model.write.shacl(shacl_file_name)
-            ```
-        """
-
-        filepath = self._prepare_ttl_filepath(io)
-        exporter = exporters.SHACLExporter()
-        self._state.data_model_store.export_to_file(exporter, filepath)
-        return None
-
-    def _prepare_ttl_filepath(self, io: str | Path) -> Path:
-        """Ensures the filepath has a .ttl extension, adding it if missing."""
-        filepath = NeatReader.create(io).materialize_path()
-        if filepath.suffix != ".ttl":
-            warnings.filterwarnings("default")
-            warnings.warn("File extension is not .ttl, adding it to the file name", stacklevel=2)
-            filepath = filepath.with_suffix(".ttl")
-        return filepath