cognite-neat 0.93.0__tar.gz → 0.95.0__tar.gz

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.93.0
+Version: 0.95.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -30,7 +30,7 @@ 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.9.2,<4.0.0)
+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"

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_rules/models/dms/_rules.py

@@ -5,6 +5,7 @@ from collections.abc import Hashable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
+import pandas as pd
 from cognite.client import data_modeling as dm
 from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
@@ -451,3 +452,18 @@ class DMSRules(BaseRules):
         from ._exporter import _DMSExporter
 
         return _DMSExporter(self, include_pipeline, instance_space).to_schema()
+
+    def _repr_html_(self) -> str:
+        summary = {
+            "type": "Physical Data Model",
+            "intended for": "DMS Architect",
+            "name": self.metadata.name,
+            "space": self.metadata.space,
+            "external_id": self.metadata.external_id,
+            "version": self.metadata.version,
+            "views": len(self.views),
+            "containers": len(self.containers) if self.containers else 0,
+            "properties": len(self.properties),
+        }
+
+        return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_rules/models/dms/_rules_input.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Literal
 
+import pandas as pd
 from cognite.client import data_modeling as dm
 
 from cognite.neat._rules.models._base_input import InputComponent, InputRules
@@ -291,3 +292,18 @@ class DMSInputRules(InputRules[DMSRules]):
             "Last": last,
             "Reference": reference,
         }
+
+    def _repr_html_(self) -> str:
+        summary = {
+            "type": "Physical Data Model",
+            "intended for": "DMS Architect",
+            "name": self.metadata.name,
+            "space": self.metadata.space,
+            "external_id": self.metadata.external_id,
+            "version": self.metadata.version,
+            "views": len(self.views),
+            "containers": len(self.containers) if self.containers else 0,
+            "properties": len(self.properties),
+        }
+
+        return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_rules/models/information/_rules.py

@@ -4,6 +4,7 @@ from collections.abc import Hashable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar
 
+import pandas as pd
 from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace
@@ -380,3 +381,16 @@ class InformationRules(BaseRules):
         from cognite.neat._rules.transformers._converters import _InformationRulesConverter
 
         return _InformationRulesConverter(self).as_dms_rules()
+
+    def _repr_html_(self) -> str:
+        summary = {
+            "type": "Logical Data Model",
+            "intended for": "Information Architect",
+            "name": self.metadata.name,
+            "external_id": self.metadata.prefix,
+            "version": self.metadata.version,
+            "classes": len(self.classes),
+            "properties": len(self.properties),
+        }
+
+        return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_rules/models/information/_rules_input.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Literal
 
+import pandas as pd
 from rdflib import Namespace
 
 from cognite.neat._rules.models._base_input import InputComponent, InputRules
@@ -144,3 +145,16 @@ class InformationInputRules(InputRules[InformationRules]):
             Last=last,
             Reference=reference,
         )
+
+    def _repr_html_(self) -> str:
+        summary = {
+            "type": "Logical Data Model",
+            "intended for": "Information Architect",
+            "name": self.metadata.name,
+            "external_id": self.metadata.prefix,
+            "version": self.metadata.version,
+            "classes": len(self.classes),
+            "properties": len(self.properties),
+        }
+
+        return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_session/_base.py

@@ -1,13 +1,11 @@
 from typing import Literal, cast
 
-import pandas as pd
 from cognite.client import CogniteClient
 
 from cognite.neat._issues import IssueList
 from cognite.neat._rules import importers
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.models import DMSRules
-from cognite.neat._rules.models._base_input import InputComponent
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import ConvertToRules, VerifyAnyRules
@@ -72,13 +70,10 @@ class NeatSession:
 
         output = []
         if state.input_rules and not state.verified_rules:
-            metadata = cast(InputComponent, state.input_rule.rules.metadata)  # type: ignore[union-attr]
-            table = pd.DataFrame([metadata.dump()]).T._repr_html_()  # type: ignore[operator]
-            output.append(f"<H2>Raw Data Model</H2><br />{table}")
+            output.append(f"<H2>Raw Data Model</H2><br />{state.input_rule.rules._repr_html_()}")  # type: ignore
 
         if state.verified_rules:
-            table = pd.DataFrame([state.last_verified_rule.metadata.model_dump()]).T._repr_html_()  # type: ignore[operator]
-            output.append(f"<H2>Data Model</H2><br />{table}")
+            output.append(f"<H2>Data Model</H2><br />{state.last_verified_rule._repr_html_()}")  # type: ignore
 
         if state.has_store:
             output.append(f"<H2>Instances</H2> {state.store._repr_html_()}")

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_session/_prepare.py

@@ -9,8 +9,10 @@ from cognite.neat._rules.models.information._rules_input import InformationInput
 from cognite.neat._rules.transformers import ReduceCogniteModel, ToCompliantEntities, ToExtension
 
 from ._state import SessionState
+from .exceptions import intercept_session_exceptions
 
 
+@intercept_session_exceptions
 class PrepareAPI:
     def __init__(self, state: SessionState, verbose: bool) -> None:
         self._state = state
@@ -18,6 +20,7 @@ class PrepareAPI:
         self.data_model = DataModelPrepareAPI(state, verbose)
 
 
+@intercept_session_exceptions
 class DataModelPrepareAPI:
     def __init__(self, state: SessionState, verbose: bool) -> None:
         self._state = state

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_session/_read.py

@@ -12,8 +12,10 @@ from cognite.neat._rules._shared import ReadRules
 
 from ._state import SessionState
 from ._wizard import NeatObjectType, RDFFileType, object_wizard, rdf_dm_wizard
+from .exceptions import intercept_session_exceptions
 
 
+@intercept_session_exceptions
 class ReadAPI:
     def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
         self._state = state
@@ -23,6 +25,7 @@ class ReadAPI:
         self.excel = ExcelReadAPI(state, client, verbose)
 
 
+@intercept_session_exceptions
 class BaseReadAPI:
     def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
         self._state = state
@@ -47,6 +50,7 @@ class BaseReadAPI:
             raise ValueError(f"Expected str or Path, got {type(io)}")
 
 
+@intercept_session_exceptions
 class CDFReadAPI(BaseReadAPI):
     def data_model(self, data_model_id: DataModelIdentifier) -> IssueList:
         if self._client is None:
@@ -58,6 +62,7 @@ class CDFReadAPI(BaseReadAPI):
         return input_rules.issues
 
 
+@intercept_session_exceptions
 class ExcelReadAPI(BaseReadAPI):
     def __call__(self, io: Any) -> IssueList:
         filepath = self._return_filepath(io)
@@ -66,6 +71,7 @@ class ExcelReadAPI(BaseReadAPI):
         return input_rules.issues
 
 
+@intercept_session_exceptions
 class RDFReadAPI(BaseReadAPI):
     def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
         super().__init__(state, client, verbose)

cognite_neat-0.95.0/cognite/neat/_session/_show.py

@@ -0,0 +1,278 @@
+import random
+from typing import Any, cast
+
+import networkx as nx
+from ipycytoscape import CytoscapeWidget  # type: ignore
+from IPython.display import display
+
+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
+from cognite.neat._rules.models.information._rules import InformationRules
+from cognite.neat._session.exceptions import NeatSessionError
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+
+from ._state import SessionState
+from .exceptions import intercept_session_exceptions
+
+
+@intercept_session_exceptions
+class ShowAPI:
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+        self.data_model = ShowDataModelAPI(self._state)
+        self.instances = ShowInstanceAPI(self._state)
+
+
+@intercept_session_exceptions
+class ShowInstanceAPI:
+    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
+
+    @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)",
+            },
+        }
+
+        template["selector"] = f'node[type = "{type_}"]'  # type: ignore
+        template["css"]["background-color"] = color
+
+        return template
+
+
+@intercept_session_exceptions
+class ShowDataModelAPI:
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+
+    def __call__(self) -> Any:
+        if not self._state.last_verified_dms_rules and not self._state.last_verified_information_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()
+
+        widget = self._generate_widget()
+        widget.graph.add_graph_from_networkx(NxGraph)
+        return display(widget)
+
+    def _generate_dms_di_graph(self) -> nx.DiGraph:
+        """Generate a DiGraph from the last verified DMS rules."""
+        NxGraph = nx.DiGraph()
+
+        # Add nodes and edges from Views sheet
+        for view in cast(DMSRules, self._state.last_verified_dms_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)
+
+            # 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)
+
+                    NxGraph.add_edge(view.view.suffix, implement.suffix, label="implements")
+
+        # Add nodes and edges from Properties sheet
+        for prop_ in cast(DMSRules, self._state.last_verified_dms_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)
+
+        return NxGraph
+
+    def _generate_info_di_graph(self) -> nx.DiGraph:
+        """Generate nodes and edges for the last verified Information rules for DiGraph."""
+
+        NxGraph = nx.DiGraph()
+
+        # Add nodes and edges from Views sheet
+        for class_ in cast(InformationRules, self._state.last_verified_information_rules).classes:
+            # if possible use human readable label coming from the view name
+            if not NxGraph.has_node(class_.class_.suffix):
+                NxGraph.add_node(
+                    class_.class_.suffix,
+                    label=class_.name or class_.class_.suffix,
+                )
+
+            # add implements 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")
+
+        # Add nodes and edges from Properties sheet
+        for prop_ in cast(InformationRules, self._state.last_verified_information_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)
+
+                label = f"{prop_.property_} [{1 if prop_.is_mandatory else 0}..{ '' if prop_.is_list else 1}]"
+                NxGraph.add_edge(
+                    prop_.class_.suffix,
+                    cast(ClassEntity, prop_.value_type).suffix,
+                    label=label,
+                )
+
+        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 widget

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_session/_to.py

@@ -8,8 +8,10 @@ from cognite.neat._rules import exporters
 from cognite.neat._session._wizard import space_wizard
 
 from ._state import SessionState
+from .exceptions import intercept_session_exceptions
 
 
+@intercept_session_exceptions
 class ToAPI:
     def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
         self._state = state
@@ -39,6 +41,7 @@ class ToAPI:
         return None
 
 
+@intercept_session_exceptions
 class CDFToAPI:
     def __init__(self, state: SessionState, client: CogniteClient | None, verbose: bool) -> None:
         self._client = client

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_session/exceptions.py

@@ -23,6 +23,8 @@ def _intercept_session_exceptions(func: Callable):
             return func(*args, **kwargs)
         except NeatSessionError as e:
             action = func.__name__
+            if action == "__call__":
+                action = func.__qualname__.removesuffix(".__call__").removesuffix("API")
             print(f"{_PREFIX} Cannot {action}: {e}")
 
     return wrapper
@@ -33,10 +35,11 @@ def intercept_session_exceptions(cls: type):
     while to_check:
         cls = to_check.pop()
         for attr_name in dir(cls):
-            if not attr_name.startswith("_"):
-                attr = getattr(cls, attr_name)
-                if callable(attr):
-                    setattr(cls, attr_name, _intercept_session_exceptions(attr))
-                elif isinstance(attr, type):
-                    to_check.append(attr)
+            if attr_name.startswith("_") and not attr_name == "__call__":
+                continue
+            attr = getattr(cls, attr_name)
+            if callable(attr):
+                setattr(cls, attr_name, _intercept_session_exceptions(attr))
+            elif isinstance(attr, type):
+                to_check.append(attr)
     return cls

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/cognite/neat/_store/_base.py

@@ -3,7 +3,7 @@ import warnings
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, cast
+from typing import cast
 
 import pandas as pd
 from pandas import Index
@@ -383,6 +383,6 @@ class NeatGraphStore:
             ],
             ignore_index=True,
         )
-        shorter_summary.index = cast(Index[Any], indexes)
+        shorter_summary.index = cast(Index, indexes)
 
         return shorter_summary

cognite_neat-0.95.0/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.95.0"

{cognite_neat-0.93.0 → cognite_neat-0.95.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.93.0"
+version = "0.95.0"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -62,7 +62,7 @@ urllib3 = "^2"
 openpyxl = "*"
 networkx = "^3.4.2"
 ipycytoscape = "^1.3.3"
-matplotlib = "^3.9.2"
+matplotlib = "=3.5.2"
 
 
 # Notebook

cognite_neat-0.93.0/cognite/neat/_session/_show.py

@@ -1,96 +0,0 @@
-from typing import Any, cast
-
-import networkx as nx
-from ipycytoscape import CytoscapeWidget  # type: ignore
-from IPython.display import display
-
-from cognite.neat._rules.models.dms._rules import DMSRules
-from cognite.neat._rules.models.entities._single_value import ViewEntity
-
-from ._state import SessionState
-
-
-class ShowAPI:
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-        self.data_model = ShowDataModelAPI(self._state)
-
-
-class ShowDataModelAPI:
-    def __init__(self, state: SessionState) -> None:
-        self._state = state
-
-    def __call__(self) -> Any:
-        if self._state.last_verified_dms_rules:
-            digraph = self._generate_dms_di_graph()
-            widget = self._generate_widget()
-            widget.graph.add_graph_from_networkx(digraph)
-            return display(widget)
-
-    def _generate_dms_di_graph(self) -> nx.DiGraph:
-        """Generate a DiGraph from the last verified DMS rules."""
-        G = nx.DiGraph()
-
-        nodes, edges = self._generate_dms_rules_nodes_and_edges()
-        G.add_nodes_from(nodes)
-        G.add_edges_from(edges)
-        for node in G.nodes:
-            G.nodes[node]["label"] = node
-
-        return G
-
-    def _generate_dms_rules_nodes_and_edges(self) -> tuple[list[str], list[tuple[str, str, dict]]]:
-        """Generate nodes and edges for the last verified DMS rules for DiGraph."""
-
-        nodes = []
-        edges = []
-
-        for prop_ in cast(DMSRules, self._state.last_verified_dms_rules).properties:
-            nodes.append(prop_.view.suffix)
-
-            if prop_.connection and isinstance(prop_.value_type, ViewEntity):
-                label = f"{prop_.property_} [{0 if prop_.nullable else 1}..{ '' if prop_.is_list else 1}]"
-                edges.append((prop_.view.suffix, prop_.value_type.suffix, {"label": label}))
-
-        for view in cast(DMSRules, self._state.last_verified_dms_rules).views:
-            nodes.append(view.view.suffix)
-
-            if view.implements:
-                for implement in view.implements:
-                    edges.append((view.view.suffix, implement.suffix, {"label": "implements"}))
-
-        return nodes, edges
-
-    def _generate_widget(self):
-        """Generates an empty a CytoscapeWidget."""
-        widget = CytoscapeWidget()
-        widget.layout.height = "500px"
-
-        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",
-                    },
-                },
-            ]
-        )
-
-        return widget

cognite_neat-0.93.0/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.93.0"