cognite-neat 0.123.20__py3-none-any.whl → 0.123.22__py3-none-any.whl

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.20"
+__version__ = "0.123.22"
 __engine__ = "^2.0.4"

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

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

cognite/neat/session/_session/{_data_model.py → _data_model/_read.py}

@@ -1,6 +1,9 @@
-from typing import Any, Literal
+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
@@ -12,14 +15,7 @@ from cognite.neat.plugins.data_model.importers._base import DataModelImporterPlu
 from cognite.neat.session._state import SessionState
 from cognite.neat.session.exceptions import NeatSessionError, 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)
+InternalReaderName = Literal["excel", "cdf", "ontology", "yaml"]
 
 
 @session_class_wrapper
@@ -27,28 +23,43 @@ class ReadAPI:
     def __init__(self, state: SessionState) -> None:
         self._state = state
 
-    def __call__(self, name: str, io: str | Path, **kwargs: Any) -> IssueList:
-        """Provides access to the external plugins for data model importing.
+    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) plugin is handling.
-            io (str | Path | None): The input/output interface for the plugin.
-            **kwargs (Any): Additional keyword arguments for the plugin.
+            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 plugin to understand
+            Users must consult the documentation of the reader to understand
             what keyword arguments are supported.
         """
 
-        # These are internal readers that are not plugins
-        if name.strip().lower() == "excel":
-            return self.excel(io, **kwargs)
-        elif name.strip().lower() == "ontology":
-            return self.ontology(io)
-        elif name.strip().lower() == "yaml":
-            return self.yaml(io, **kwargs)
-        else:
-            return self._plugin(name, io, **kwargs)
+        # 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.
@@ -82,6 +93,34 @@ class ReadAPI:
 
         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.

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

@@ -0,0 +1,43 @@
+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._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.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

@@ -0,0 +1,147 @@
+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-0.123.20.dist-info → cognite_neat-0.123.22.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=tUfZIhsXsTuZtKqqfKwmQe_3linzeB0aoFlEj2fZHAQ,47
+cognite/neat/_version.py,sha256=F_PTAPIzLmGDm4RPxIsNpijbHtxGJrALannZQ5hHcUY,47
 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
@@ -185,13 +185,16 @@ cognite/neat/session/_to.py,sha256=_R-UB3iEIQoa12kTD7tuSrRDdbySQXQg_mzbn5t-7bg,1
 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.py,sha256=id2chqUIA8tkxc9tTT7RiGWs-GzHC4LnzNkq-mfBIW4,6347
+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=wF83vLtmgyGCM2zxnHq0m3-sPQXQamObc58u2kSN7nQ,1666
+cognite/neat/session/_session/_data_model/_show.py,sha256=yX4BTIeBzcCcllfJvGm8g4qy13heFmcJtpXPixI8T2o,5835
 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.20.dist-info/METADATA,sha256=O8qdN1hncWgpZrnj6h4aeeoZlbtTG2Loe7qTGpHUuzA,9172
-cognite_neat-0.123.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.20.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.20.dist-info/RECORD,,
+cognite_neat-0.123.22.dist-info/METADATA,sha256=cIvYIW2976HqHJSdiseJuSEG3om5ldv2Z-csEbZQt6Y,9172
+cognite_neat-0.123.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.22.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.22.dist-info/RECORD,,