cognite-neat 0.95.0__py3-none-any.whl → 0.96.1__py3-none-any.whl

cognite/neat/_session/_show.py

@@ -1,10 +1,12 @@
+import colorsys
 import random
 from typing import Any, cast
 
 import networkx as nx
-from ipycytoscape import CytoscapeWidget  # type: ignore
-from IPython.display import display
+from IPython.display import HTML, display
+from pyvis.network import Network as PyVisNetwork  # type: ignore
 
+from cognite.neat._constants import IN_NOTEBOOK, IN_PYODIDE
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models.dms._rules import DMSRules
 from cognite.neat._rules.models.entities._single_value import ClassEntity, ViewEntity
@@ -25,254 +27,211 @@ class ShowAPI:
 
 
 @intercept_session_exceptions
-class ShowInstanceAPI:
+class ShowBaseAPI:
     def __init__(self, state: SessionState) -> None:
         self._state = state
 
-    def __call__(self) -> Any:
-        if not self._state.store.graph:
-            raise NeatSessionError("No instances available. Try using [bold].read[/bold] to load instances.")
-
-        widget = CytoscapeWidget()
-        widget.layout.height = "700px"
-
-        NxGraph, types = self._generate_instance_di_graph_and_types()
-        widget_style = self._generate_cytoscape_widget_style(types)
-        widget.set_style(widget_style)
-
-        widget.graph.add_graph_from_networkx(NxGraph)
-        print("Max of 100 nodes and edges are displayed, which are randomly selected.")
-
-        return display(widget)
-
-    def _generate_instance_di_graph_and_types(self) -> tuple[nx.DiGraph, set[str]]:
-        query = """
-        SELECT ?s ?p ?o ?ts ?to WHERE {
-            ?s ?p ?o .
-            FILTER(isIRI(?o))  # Example filter to check if ?o is an IRI (object type)
-            FILTER(BOUND(?o))
-            FILTER(?p != rdf:type)
-
-            ?s a ?ts .
-            ?o a ?to .
-        }
-        LIMIT 100
-        """
-
-        NxGraph = nx.DiGraph()
-
-        types = set()
-
-        for (  # type: ignore
-            subject,
-            property_,
-            object,
-            subject_type,
-            object_type,
-        ) in self._state.store.graph.query(query):
-            subject = remove_namespace_from_uri(subject)
-            property_ = remove_namespace_from_uri(property_)
-            object = remove_namespace_from_uri(object)
-            subject_type = remove_namespace_from_uri(subject_type)
-            object_type = remove_namespace_from_uri(object_type)
-
-            NxGraph.add_node(subject, label=subject, type=subject_type)
-            NxGraph.add_node(object, label=object, type=object_type)
-            NxGraph.add_edge(subject, object, label=property_)
-
-            types.add(subject_type)
-            types.add(object_type)
-
-        return NxGraph, types
-
-    def _generate_cytoscape_widget_style(self, types: set[str]) -> list[dict]:
-        widget_style = [
-            {
-                "selector": "edge",
-                "style": {
-                    "width": 1,
-                    "target-arrow-shape": "triangle",
-                    "curve-style": "bezier",
-                    "label": "data(label)",
-                    "font-size": "8px",
-                    "line-color": "black",
-                    "target-arrow-color": "black",
-                },
-            },
-        ]
-
-        colors = self._generate_hex_colors(len(types))
-
-        for i, type_ in enumerate(types):
-            widget_style.append(self._generate_node_cytoscape_style(type_, colors[i]))
-
-        return widget_style
-
-    @staticmethod
-    def _generate_hex_colors(n: int) -> list[str]:
-        """Generate a list of N random HEX color codes."""
-        random.seed(42)  # Set a seed for deterministic behavior
-        hex_colors = []
-        for _ in range(n):
-            color = f"#{random.randint(0, 0xFFFFFF):06x}"
-            hex_colors.append(color)
-        return hex_colors
+    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,
+        )
 
-    @staticmethod
-    def _generate_node_cytoscape_style(type_: str, color: str) -> dict:
-        template = {
-            "css": {
-                "content": "data(label)",
-                "text-valign": "center",
-                "color": "black",
-                "font-size": "10px",
-                "width": "mapData(score, 0, 1, 10, 50)",
-                "height": "mapData(score, 0, 1, 10, 50)",
-            },
-        }
+        # Change the plotting layout
+        net.repulsion(
+            node_distance=100,
+            central_gravity=0.3,
+            spring_length=200,
+            spring_strength=0.05,
+            damping=0.09,
+        )
 
-        template["selector"] = f'node[type = "{type_}"]'  # type: ignore
-        template["css"]["background-color"] = color
+        net.from_nx(di_graph)
+        if IN_PYODIDE:
+            net.write_html(name)
+            return display(HTML(name))
 
-        return template
+        else:
+            return net.show(name)
 
 
 @intercept_session_exceptions
-class ShowDataModelAPI:
+class ShowDataModelAPI(ShowBaseAPI):
     def __init__(self, state: SessionState) -> None:
+        super().__init__(state)
         self._state = state
 
     def __call__(self) -> Any:
-        if not self._state.last_verified_dms_rules and not self._state.last_verified_information_rules:
+        if not self._state.has_verified_rules:
             raise NeatSessionError(
                 "No verified data model available. Try using [bold].verify()[/bold] to verify data model."
             )
 
-        if self._state.last_verified_dms_rules:
-            NxGraph = self._generate_dms_di_graph()
-        elif self._state.last_verified_information_rules:
-            NxGraph = self._generate_info_di_graph()
+        try:
+            di_graph = self._generate_dms_di_graph(self._state.last_verified_dms_rules)
+            name = "dms_data_model.html"
+        except NeatSessionError:
+            di_graph = self._generate_info_di_graph(self._state.last_verified_information_rules)
+            name = "information_data_model.html"
 
-        widget = self._generate_widget()
-        widget.graph.add_graph_from_networkx(NxGraph)
-        return display(widget)
+        return self._generate_visualization(di_graph, name)
 
-    def _generate_dms_di_graph(self) -> nx.DiGraph:
+    def _generate_dms_di_graph(self, rules: DMSRules) -> nx.DiGraph:
         """Generate a DiGraph from the last verified DMS rules."""
-        NxGraph = nx.DiGraph()
+        di_graph = nx.DiGraph()
 
         # Add nodes and edges from Views sheet
-        for view in cast(DMSRules, self._state.last_verified_dms_rules).views:
+        for view in rules.views:
             # if possible use human readable label coming from the view name
-            if not NxGraph.has_node(view.view.suffix):
-                NxGraph.add_node(view.view.suffix, label=view.name or view.view.suffix)
+            if not di_graph.has_node(view.view.suffix):
+                di_graph.add_node(view.view.suffix, label=view.name or view.view.suffix)
 
             # add implements as edges
             if view.implements:
                 for implement in view.implements:
-                    if not NxGraph.has_node(implement.suffix):
-                        NxGraph.add_node(implement.suffix, label=implement.suffix)
+                    if not di_graph.has_node(implement.suffix):
+                        di_graph.add_node(implement.suffix, label=implement.suffix)
 
-                    NxGraph.add_edge(view.view.suffix, implement.suffix, label="implements")
+                    di_graph.add_edge(
+                        view.view.suffix,
+                        implement.suffix,
+                        label="implements",
+                        dashes=True,
+                    )
 
         # Add nodes and edges from Properties sheet
-        for prop_ in cast(DMSRules, self._state.last_verified_dms_rules).properties:
+        for prop_ in rules.properties:
             if prop_.connection and isinstance(prop_.value_type, ViewEntity):
-                if not NxGraph.has_node(prop_.view.suffix):
-                    NxGraph.add_node(prop_.view.suffix, label=prop_.view.suffix)
-
-                label = f"{prop_.property_} [{0 if prop_.nullable else 1}..{ '' if prop_.is_list else 1}]"
-                NxGraph.add_edge(prop_.view.suffix, prop_.value_type.suffix, label=label)
+                if not di_graph.has_node(prop_.view.suffix):
+                    di_graph.add_node(prop_.view.suffix, label=prop_.view.suffix)
+                di_graph.add_edge(
+                    prop_.view.suffix,
+                    prop_.value_type.suffix,
+                    label=prop_.name or prop_.property_,
+                )
 
-        return NxGraph
+        return di_graph
 
-    def _generate_info_di_graph(self) -> nx.DiGraph:
-        """Generate nodes and edges for the last verified Information rules for DiGraph."""
+    def _generate_info_di_graph(self, rules: InformationRules) -> nx.DiGraph:
+        """Generate DiGraph representing information data model."""
 
-        NxGraph = nx.DiGraph()
+        di_graph = nx.DiGraph()
 
         # Add nodes and edges from Views sheet
-        for class_ in cast(InformationRules, self._state.last_verified_information_rules).classes:
+        for class_ in rules.classes:
             # if possible use human readable label coming from the view name
-            if not NxGraph.has_node(class_.class_.suffix):
-                NxGraph.add_node(
+            if not di_graph.has_node(class_.class_.suffix):
+                di_graph.add_node(
                     class_.class_.suffix,
                     label=class_.name or class_.class_.suffix,
                 )
 
-            # add implements as edges
+            # add subClassOff as edges
             if class_.parent:
                 for parent in class_.parent:
-                    if not NxGraph.has_node(parent.suffix):
-                        NxGraph.add_node(parent.suffix, label=parent.suffix)
-
-                    NxGraph.add_edge(class_.class_.suffix, parent.suffix, label="subClassOf")
+                    if not di_graph.has_node(parent.suffix):
+                        di_graph.add_node(parent.suffix, label=parent.suffix)
+                    di_graph.add_edge(
+                        class_.class_.suffix,
+                        parent.suffix,
+                        label="subClassOf",
+                        dashes=True,
+                    )
 
         # Add nodes and edges from Properties sheet
-        for prop_ in cast(InformationRules, self._state.last_verified_information_rules).properties:
+        for prop_ in rules.properties:
             if prop_.type_ == EntityTypes.object_property:
-                if not NxGraph.has_node(prop_.class_.suffix):
-                    NxGraph.add_node(prop_.class_.suffix, label=prop_.class_.suffix)
+                if not di_graph.has_node(prop_.class_.suffix):
+                    di_graph.add_node(prop_.class_.suffix, label=prop_.class_.suffix)
 
-                label = f"{prop_.property_} [{1 if prop_.is_mandatory else 0}..{ '' if prop_.is_list else 1}]"
-                NxGraph.add_edge(
+                di_graph.add_edge(
                     prop_.class_.suffix,
                     cast(ClassEntity, prop_.value_type).suffix,
-                    label=label,
+                    label=prop_.name or prop_.property_,
                 )
 
-        return NxGraph
-
-    def _generate_widget(self):
-        """Generates an empty a CytoscapeWidget."""
-        widget = CytoscapeWidget()
-        widget.layout.height = "700px"
-
-        widget.set_style(
-            [
-                {
-                    "selector": "node",
-                    "css": {
-                        "content": "data(label)",
-                        "text-valign": "center",
-                        "color": "black",
-                        "background-color": "#33C4FF",
-                        "font-size": "10px",
-                        "width": "mapData(score, 0, 1, 10, 50)",
-                        "height": "mapData(score, 0, 1, 10, 50)",
-                    },
-                },
-                {
-                    "selector": "edge",
-                    "style": {
-                        "width": 1,
-                        "target-arrow-shape": "triangle",
-                        "curve-style": "bezier",
-                        "label": "data(label)",
-                        "font-size": "8px",
-                        "line-color": "black",
-                        "target-arrow-color": "black",
-                    },
-                },
-                {
-                    "selector": 'edge[label = "subClassOf"]',
-                    "style": {
-                        "line-color": "grey",
-                        "target-arrow-color": "grey",
-                        "line-style": "dashed",
-                        "font-size": "8px",
-                    },
-                },
-                {
-                    "selector": 'edge[label = "implements"]',
-                    "style": {
-                        "line-color": "grey",
-                        "target-arrow-color": "grey",
-                        "line-style": "dashed",
-                        "font-size": "8px",
-                    },
-                },
-            ]
-        )
+        return di_graph
+
+
+@intercept_session_exceptions
+class ShowInstanceAPI(ShowBaseAPI):
+    def __init__(self, state: SessionState) -> None:
+        super().__init__(state)
+        self._state = state
+
+    def __call__(self) -> Any:
+        if not self._state.store.graph:
+            raise NeatSessionError("No instances available. Try using [bold].read[/bold] to load instances.")
+
+        di_graph = self._generate_instance_di_graph_and_types()
+        return self._generate_visualization(di_graph, name="instances.html")
+
+    def _generate_instance_di_graph_and_types(self) -> nx.DiGraph:
+        query = """
+        SELECT ?s ?p ?o ?ts ?to WHERE {
+            ?s ?p ?o .
+            FILTER(isIRI(?o))  # Example filter to check if ?o is an IRI (object type)
+            FILTER(BOUND(?o))
+            FILTER(?p != rdf:type)
 
-        return widget
+            ?s a ?ts .
+            ?o a ?to .
+        }
+        LIMIT 200
+        """
+
+        di_graph = nx.DiGraph()
+
+        types = [type_ for type_, _ in self._state.store.queries.summarize_instances()]
+        hex_colored_types = self._generate_hex_color_per_type(types)
+
+        for (  # type: ignore
+            subject,
+            property_,
+            object,
+            subject_type,
+            object_type,
+        ) in self._state.store.graph.query(query):
+            subject = remove_namespace_from_uri(subject)
+            property_ = remove_namespace_from_uri(property_)
+            object = remove_namespace_from_uri(object)
+            subject_type = remove_namespace_from_uri(subject_type)
+            object_type = remove_namespace_from_uri(object_type)
+
+            di_graph.add_node(
+                subject,
+                label=subject,
+                type=subject_type,
+                title=subject_type,
+                color=hex_colored_types[subject_type],
+            )
+            di_graph.add_node(
+                object,
+                label=object,
+                type=object_type,
+                title=object_type,
+                color=hex_colored_types[object_type],
+            )
+            di_graph.add_edge(subject, object, label=property_, color="grey")
+
+        return di_graph
+
+    @staticmethod
+    def _generate_hex_color_per_type(types: list[str]) -> dict:
+        hex_colored_types = {}
+        random.seed(381)
+        for type_ in types:
+            hue = random.random()
+            saturation = random.uniform(0.5, 1.0)
+            lightness = random.uniform(0.4, 0.6)
+            rgb = colorsys.hls_to_rgb(hue, lightness, saturation)
+            hex_color = f"#{int(rgb[0] * 255):02x}{int(rgb[1] * 255):02x}{int(rgb[2] * 255):02x}"
+            hex_colored_types[type_] = hex_color
+        return hex_colored_types

cognite/neat/_session/_state.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Literal, cast
 
+from cognite.neat._issues import IssueList
 from cognite.neat._rules._shared import ReadRules, VerifiedRules
 from cognite.neat._rules.models.dms._rules import DMSRules
 from cognite.neat._rules.models.information._rules import InformationRules
@@ -15,6 +16,7 @@ class SessionState:
     store_type: Literal["memory", "oxigraph"]
     input_rules: list[ReadRules] = field(default_factory=list)
     verified_rules: list[VerifiedRules] = field(default_factory=list)
+    issue_lists: list[IssueList] = field(default_factory=list)
     _store: NeatGraphStore | None = field(init=False, default=None)
 
     @property
@@ -49,21 +51,39 @@ class SessionState:
         return self.verified_rules[-1]
 
     @property
-    def last_verified_dms_rules(self) -> DMSRules | None:
+    def last_verified_dms_rules(self) -> DMSRules:
         if self.verified_rules:
             for rules in self.verified_rules[::-1]:
                 if isinstance(rules, DMSRules):
                     return rules
-        return None
+
+        raise NeatSessionError(
+            'No verified DMS data model. Try using  [bold].convert("DMS")[/bold]'
+            " to convert verified information model to verified DMS model."
+        )
 
     @property
-    def last_verified_information_rules(self) -> InformationRules | None:
+    def last_verified_information_rules(self) -> InformationRules:
         if self.verified_rules:
             for rules in self.verified_rules[::-1]:
                 if isinstance(rules, InformationRules):
                     return rules
-        return None
+
+        raise NeatSessionError(
+            "No verified information data model. Try using  [bold].verify()[/bold]"
+            " to convert unverified information model to verified information model."
+        )
 
     @property
     def has_store(self) -> bool:
         return self._store is not None
+
+    @property
+    def has_verified_rules(self) -> bool:
+        return bool(self.verified_rules)
+
+    @property
+    def last_issues(self) -> IssueList:
+        if not self.issue_lists:
+            raise NeatSessionError("No issues available. Try using [bold].verify()[/bold] to verify a data model.")
+        return self.issue_lists[-1]

cognite/neat/_store/_base.py

@@ -367,20 +367,23 @@ class NeatGraphStore:
     def _shorten_summary(self, summary: pd.DataFrame) -> pd.DataFrame:
         """Shorten summary to top 5 types by occurrence."""
         top_5_rows = summary.head(5)
-        last_row = summary.tail(1)
 
         indexes = [
             *top_5_rows.index.tolist(),
-            "...",
-            *last_row.index.tolist(),
         ]
+        data = [
+            top_5_rows,
+        ]
+        if len(summary) > 6:
+            last_row = summary.tail(1)
+            indexes += [
+                "...",
+                *last_row.index.tolist(),
+            ]
+            data.extend([pd.DataFrame([["..."] * summary.shape[1]], columns=summary.columns), last_row])
 
         shorter_summary = pd.concat(
-            [
-                top_5_rows,
-                pd.DataFrame([["..."] * summary.shape[1]], columns=summary.columns),
-                last_row,
-            ],
+            data,
             ignore_index=True,
         )
         shorter_summary.index = cast(Index, indexes)

cognite/neat/_utils/collection_.py

@@ -17,3 +17,7 @@ def most_occurring_element(list_of_elements: list[T_Element]) -> T_Element:
 def chunker(sequence: Sequence[T_Element], chunk_size: int) -> Iterable[Sequence[T_Element]]:
     for i in range(0, len(sequence), chunk_size):
         yield sequence[i : i + chunk_size]
+
+
+def remove_list_elements(input_list: list, elements_to_remove: list) -> list:
+    return [element for element in input_list if element not in elements_to_remove]

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.95.0"
+__version__ = "0.96.1"

{cognite_neat-0.95.0.dist-info → cognite_neat-0.96.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.95.0
+Version: 0.96.1
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -17,7 +17,6 @@ Provides-Extra: all
 Provides-Extra: docs
 Provides-Extra: google
 Provides-Extra: graphql
-Provides-Extra: jupyter
 Provides-Extra: oxi
 Provides-Extra: service
 Requires-Dist: PyYAML
@@ -28,9 +27,7 @@ Requires-Dist: fastapi (>=0,<1) ; extra == "service" or extra == "all"
 Requires-Dist: google-api-python-client ; extra == "google"
 Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
-Requires-Dist: ipycytoscape (>=1.3.3,<2.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0) ; extra == "graphql" or extra == "all"
-Requires-Dist: matplotlib (==3.5.2)
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
 Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"
@@ -49,9 +46,10 @@ Requires-Dist: pydantic (>=2,<3)
 Requires-Dist: pymdown-extensions ; extra == "docs"
 Requires-Dist: pyoxigraph (==0.3.19) ; extra == "oxi" or extra == "all"
 Requires-Dist: python-multipart (==0.0.9) ; extra == "service" or extra == "all"
+Requires-Dist: pyvis (>=0.3.2,<0.4.0)
 Requires-Dist: rdflib
 Requires-Dist: requests
-Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0) ; extra == "jupyter"
+Requires-Dist: rich[jupyter] (>=13.7.1,<14.0.0)
 Requires-Dist: schedule (>=1,<2) ; extra == "service" or extra == "all"
 Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: typing_extensions (>=4.8,<5.0) ; python_version < "3.11"