spanner-graph-notebook 1.1.2__tar.gz → 1.1.4__tar.gz

{spanner_graph_notebook-1.1.2/spanner_graph_notebook.egg-info → spanner_graph_notebook-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: spanner-graph-notebook
-Version: 1.1.2
+Version: 1.1.4
 Summary: Visually query Spanner Graph data in notebooks.
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,6 +15,7 @@ Requires-Dist: portpicker
 Requires-Dist: pydata-google-auth
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/app.js

@@ -164,6 +164,11 @@ class SpannerApp {
                                     return;
                                 }
 
+                                if (data.error) {
+                                    this.graph.showErrorStateForNode(node, error);
+                                    return;
+                                }
+
                                 const newData = this.store.appendGraphData(data.response.nodes, data.response.edges)
                                 if (newData) {
                                     // Show success message before appending data

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/graph-server.js

@@ -13,8 +13,17 @@
  * limitations under the License.
  */
 
+function isColab() {
+    return typeof google !== 'undefined'
+}
+
 class GraphServer {
     isFetching = false;
+
+    /**
+     * Port number to connect to graph server. In colab environments, this is always undefined
+     * and not used (we use colab callbacks instead).
+     */
     port = 8195;
 
     endpoints = {
@@ -58,17 +67,21 @@ class GraphServer {
     }
 
     constructor(port, params) {
-        let numericalPort = port;
-        if (typeof numericalPort !== 'number') {
-            numericalPort = Number.parseInt(numericalPort);
+        if (isColab()) {
+            this.port = undefined;
+        } else {
+            let numericalPort = port;
+            if (typeof numericalPort !== 'number') {
+                numericalPort = Number.parseInt(numericalPort);
 
-            if (isNaN(numericalPort)) {
-                console.error('Graph Server was not given a numerical port', {port});
-                return;
+                if (isNaN(numericalPort)) {
+                    console.error('Graph Server was not given a numerical port', {port});
+                    return;
+                }
             }
-        }
 
-        this.port = numericalPort;
+            this.port = numericalPort;
+        }
         this.params = params
     }
 
@@ -109,10 +122,7 @@ class GraphServer {
             }
         }
 
-        const {project, instance, database, graph} = JSON.parse(this.params);
-
         const request = {
-            project, instance, database, graph,
             uid: node.uid,
             node_labels: node.labels,
             node_properties: validProperties,
@@ -125,21 +135,18 @@ class GraphServer {
 
         this.isFetching = true;
 
-        if (typeof google !== 'undefined') {
+        if (isColab()) {
             return google.colab.kernel.invokeFunction('graph_visualization.NodeExpansion', [request, this.params])
                 .then(result => result.data['application/json'])
                 .finally(() => this.isFetching = false);
         }
 
-        // For non-Colab environment, combine params and request
-        const fullRequest = {
-            ...JSON.parse(this.params),
-            ...request
-        };
-
         return fetch(this.buildRoute(this.endpoints.postNodeExpansion), {
             method: 'POST',
-            body: JSON.stringify(fullRequest)
+            body: JSON.stringify({
+                params: this.params,
+                request
+            })
         })
             .then(response => {
                 if (!response.ok) {
@@ -161,7 +168,7 @@ class GraphServer {
 
         this.isFetching = true;
 
-        if (typeof google !== 'undefined') {
+        if (isColab()) {
             return google.colab.kernel.invokeFunction('graph_visualization.Query', [], request)
                 .then(result => result.data['application/json'])
                 .finally(() => this.isFetching = false);

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/models/node.js

@@ -39,6 +39,13 @@ class Node extends GraphObject {
      */
     identifiers = [];
 
+    /**
+     * Denotes if the node was created in the absence of a node from the query response.
+     * This may happen when a query only returns edges. The edge has UIDs for a source/destination node,
+     * but no nodes were returned from the response.
+     * @type {boolean}
+     */
+    intermediate = false;
 
     /**
      * The following properties will be set by ForceGraph.
@@ -58,6 +65,7 @@ class Node extends GraphObject {
      * @property {Object} key_property_names
      * @property {string} color
      * @property {string} identifier
+     * @property {bool} intermediate
      */
 
     /**
@@ -65,11 +73,12 @@ class Node extends GraphObject {
     * @param {NodeData} params
     */
     constructor(params) {
-        const { labels, title, properties, value, key_property_names, identifier } = params;
+        const { labels, title, properties, value, key_property_names, identifier, intermediate } = params;
         super({ labels, title, properties, key_property_names, identifier });
 
         this.value = value;
         this.instantiated = true;
+        this.intermediate = intermediate || false;
 
         // Parse the human-readable unique identifiers that
         // distinguishes a node from its peers
@@ -81,6 +90,10 @@ class Node extends GraphObject {
             }
         }
     }
+
+    isIntermediateNode() {
+        return this.intermediate;
+    }
 }
 
 if (typeof module !== 'undefined' && module.exports) {

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/spanner-config.js

@@ -207,7 +207,7 @@ class GraphConfig {
 
         for (const uid of Object.keys(this.nodes)) {
             const node = this.nodes[uid];
-            if (!node || !(node instanceof Node)) {
+            if (!node || !(node instanceof Node) || node.isIntermediateNode()) {
                 continue;
             }
 
@@ -411,7 +411,8 @@ class GraphConfig {
         const newEdges = this.parseEdges(edgesData);
 
         for (const uid of Object.keys(newNodes)) {
-            if (!this.nodes[uid]) {
+            const existingNode = this.nodes[uid];
+            if (!(existingNode instanceof Node) || existingNode.isIntermediateNode()) {
                 this.nodes[uid] = newNodes[uid];
             }
         }

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/spanner-store.js

@@ -450,11 +450,15 @@ class GraphStore {
      * @returns {string} The color for the node based on its label.
      */
     getColorForNodeByLabel(node) {
-        const defaultColor = 'rgb(100, 100, 100)';
+        const defaultColor = 'rgb(100, 100, 100)'
         if (!node || !(node instanceof Node)) {
             return defaultColor;
         }
 
+        if (node.isIntermediateNode()) {
+            return 'rgb(128, 134, 139)';
+        }
+
         const nodeColor = this.config.nodeColors[node.getLabels()];
         if (nodeColor) {
             return nodeColor;
@@ -489,7 +493,8 @@ class GraphStore {
         const newNodes = [];
         if (Array.isArray(nodesData)) {
             for (const nodeData of nodesData) {
-                if (this.config.nodes[nodeData.identifier]) {
+                const existingNode = this.config.nodes[nodeData.identifier];
+                if (existingNode && !existingNode.isIntermediateNode()) {
                     continue;
                 }
 

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/visualization/spanner-forcegraph.js

@@ -1086,6 +1086,7 @@ class GraphVisualization {
                         }
 
                         const showLabel =
+                            !node.isIntermediateNode() && (
                             // The user has chosen to view labels
                             this.store.config.showLabels ||
                             // Always show labels in Schema view
@@ -1096,7 +1097,7 @@ class GraphVisualization {
                             this.selectedNodeNeighbors.includes(node) ||
                             this.focusedNodeNeighbors.includes(node) ||
                             this.focusedEdgeNeighbors.includes(node) ||
-                            this.selectedEdgeNeighbors.includes(node);
+                            this.selectedEdgeNeighbors.includes(node));
 
                         // Init label
                         ctx.save();
@@ -1438,7 +1439,7 @@ class GraphVisualization {
      */
     _showMouseContextMenu(node, event) {
         // Don't show context menu in schema mode
-        if (this.store.config.viewMode === GraphConfig.ViewModes.SCHEMA) {
+        if (this.store.config.viewMode === GraphConfig.ViewModes.SCHEMA || node.isIntermediateNode()) {
             return;
         }
 

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/src/visualization/spanner-sidebar.js

@@ -277,7 +277,9 @@ class SidebarConstructor {
         if (this.store.config.selectedGraphObject) {
             if (this.store.config.selectedGraphObject instanceof Node) {
                 this.properties();
-                this.expandNode();
+                if (!this.store.config.selectedGraphObject.isIntermediateNode()) {
+                    this.expandNode();
+                }
                 this.neighbors();
             } else {
                 this.neighbors();

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/tests/unit/graph-server.test.ts

@@ -148,19 +148,23 @@ describe('GraphServer', () => {
                 {
                     method: 'POST',
                     body: JSON.stringify({
-                        project: 'test-project',
-                        instance: 'test-instance',
-                        database: 'test-database',
-                        graph: 'test-graph',
-                        mock: false,
-                        uid: 'node1',
-                        node_labels: ['TestLabel1'],
-                        node_properties: [{
-                            key: 'name',
-                            value: 'my-node-name',
-                            type: 'STRING'
-                        }],
-                        direction: 'OUTGOING'
+                        params: JSON.stringify({
+                            project: 'test-project',
+                            instance: 'test-instance',
+                            database: 'test-database',
+                            graph: 'test-graph',
+                            mock: false
+                        }),
+                        request: {
+                            uid: 'node1',
+                            node_labels: ['TestLabel1'],
+                            node_properties: [{
+                                key: 'name',
+                                value: 'my-node-name',
+                                type: 'STRING'
+                            }],
+                            direction: 'OUTGOING'
+                        }
                     })
                 }
             );

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/tests/unit/models/node.test.ts

@@ -57,4 +57,32 @@ describe('Node', () => {
             expect(graphNode.identifiers).toEqual(['foo', 'boolean', 'zero']);
         });
     });
+
+    describe('Intermediate Nodes', () => {
+        it('should create a non-intermediate node by default', () => {
+            const graphNode = new GraphNode(validNodeData);
+            expect(graphNode.intermediate).toBe(false);
+            expect(graphNode.isIntermediateNode()).toBe(false);
+        });
+
+        it('should create an intermediate node when specified', () => {
+            const intermediateNodeData = {
+                ...validNodeData,
+                intermediate: true
+            };
+            const graphNode = new GraphNode(intermediateNodeData);
+            expect(graphNode.intermediate).toBe(true);
+            expect(graphNode.isIntermediateNode()).toBe(true);
+        });
+
+        it('should handle undefined intermediate flag', () => {
+            const nodeData = {
+                ...validNodeData,
+                intermediate: undefined
+            };
+            const graphNode = new GraphNode(nodeData);
+            expect(graphNode.intermediate).toBe(false);
+            expect(graphNode.isIntermediateNode()).toBe(false);
+        });
+    });
 });

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/tests/unit/spanner-config.test.ts

@@ -306,4 +306,73 @@ describe('GraphConfig', () => {
             expect(mockConfig.nodeCount).toBe(2);
         });
     });
+
+    describe('Intermediate Node Handling', () => {
+        test('should exclude intermediate nodes from color assignment', () => {
+            const mockConfig = new GraphConfig({
+                nodesData: [
+                    { identifier: "1", labels: ['Person'], properties: {} },
+                    { identifier: "2", labels: ['Movie'], properties: {}, intermediate: true }
+                ],
+                edgesData: [],
+                colorPalette: ['#FF0000'],
+                colorScheme: GraphConfig.ColorScheme.LABEL,
+                rowsData: [],
+                schemaData: {},
+                queryResult: {}
+            });
+
+            // Should only assign color to non-intermediate node
+            expect(Object.keys(mockConfig.nodeColors).length).toBe(1);
+            expect(mockConfig.nodeColors['Person']).toBeDefined();
+        });
+
+        test('should allow replacing intermediate nodes with real nodes', () => {
+            const mockConfig = new GraphConfig({
+                nodesData: [
+                    { identifier: "1", labels: ['Person'], properties: {}, intermediate: true }
+                ],
+                edgesData: [],
+                colorPalette: ['#FF0000'],
+                colorScheme: GraphConfig.ColorScheme.LABEL,
+                rowsData: [],
+                schemaData: {},
+                queryResult: {}
+            });
+
+            // Append a real node with the same identifier
+            mockConfig.appendGraphData([
+                { identifier: "1", labels: ['Person'], properties: { name: 'John' } }
+            ], []);
+
+            const node = mockConfig.nodes["1"];
+            expect(node).toBeDefined();
+            expect(node.isIntermediateNode()).toBe(false);
+            expect(node.properties.name).toBe('John');
+        });
+
+        test('should not replace real nodes with intermediate nodes', () => {
+            const mockConfig = new GraphConfig({
+                nodesData: [
+                    { identifier: "1", labels: ['Person'], properties: { name: 'John' } }
+                ],
+                edgesData: [],
+                colorPalette: ['#FF0000'],
+                colorScheme: GraphConfig.ColorScheme.LABEL,
+                rowsData: [],
+                schemaData: {},
+                queryResult: {}
+            });
+
+            // Try to append an intermediate node with the same identifier
+            mockConfig.appendGraphData([
+                { identifier: "1", labels: ['Person'], properties: {}, intermediate: true }
+            ], []);
+
+            const node = mockConfig.nodes["1"];
+            expect(node).toBeDefined();
+            expect(node.isIntermediateNode()).toBe(false);
+            expect(node.properties.name).toBe('John');
+        });
+    });
 });

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/frontend/tests/unit/spanner-store.test.ts

@@ -925,4 +925,86 @@ describe('GraphStore', () => {
         expect(store.getEdgeTypesOfNodeSorted(undefined)).toEqual([]);
         expect(store.getEdgeTypesOfNodeSorted({} as any)).toEqual([]);
     });
+
+    describe('Intermediate Node Handling', () => {
+        test('should return correct color for intermediate nodes', () => {
+            const intermediateNode = new GraphNode({
+                identifier: "1",
+                labels: ['Person'],
+                properties: {},
+                intermediate: true
+            });
+
+            const color = store.getColorForNodeByLabel(intermediateNode);
+            expect(color).toBe('rgb(128, 134, 139)');
+        });
+
+        test('should return correct color for non-intermediate nodes', () => {
+            const regularNode = new GraphNode({
+                identifier: "1",
+                labels: ['Person'],
+                properties: {}
+            });
+
+            // Set up the node color explicitly for the test
+            store.config.nodeColors['Person'] = '#FF0000';
+            
+            const color = store.getColorForNodeByLabel(regularNode);
+            expect(color).toBe('#FF0000'); // Now we expect the color we explicitly set
+        });
+
+        test('should handle node expansion requests for intermediate nodes', () => {
+            const intermediateNode = new GraphNode({
+                identifier: "1",
+                labels: ['Person'],
+                properties: {},
+                intermediate: true
+            });
+
+            // Mock the event listener
+            const mockCallback = jest.fn();
+            store.addEventListener(GraphStore.EventTypes.NODE_EXPANSION_REQUEST, mockCallback);
+
+            // Request expansion
+            store.requestNodeExpansion(intermediateNode, 'OUTGOING', 'CONNECTS_TO');
+
+            // Verify the callback was called with correct parameters
+            expect(mockCallback).toHaveBeenCalledWith(
+                intermediateNode,
+                'OUTGOING',
+                'CONNECTS_TO',
+                expect.any(Array),
+                expect.any(Object)
+            );
+        });
+
+        test('should handle node expansion requests for non-intermediate nodes', () => {
+            const regularNode = new GraphNode({
+                identifier: "1",
+                labels: ['Person'],
+                properties: { name: 'John' }
+            });
+
+            // Mock the event listener
+            const mockCallback = jest.fn();
+            store.addEventListener(GraphStore.EventTypes.NODE_EXPANSION_REQUEST, mockCallback);
+
+            // Request expansion
+            store.requestNodeExpansion(regularNode, 'OUTGOING', 'CONNECTS_TO');
+
+            // Verify the callback was called with correct parameters
+            expect(mockCallback).toHaveBeenCalledWith(
+                regularNode,
+                'OUTGOING',
+                'CONNECTS_TO',
+                expect.arrayContaining([
+                    expect.objectContaining({
+                        key: 'name',
+                        value: 'John'
+                    })
+                ]),
+                expect.any(Object)
+            );
+        });
+    });
 });

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/setup.py

@@ -32,7 +32,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="spanner-graph-notebook",
-    version="v1.1.2",
+    version="v1.1.4",
     packages=find_packages(),
     install_requires=[
         "networkx", "numpy", "google-cloud-spanner", "ipython",

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4/spanner_graph_notebook.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: spanner-graph-notebook
-Version: 1.1.2
+Version: 1.1.4
 Summary: Visually query Spanner Graph data in notebooks.
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,6 +15,7 @@ Requires-Dist: portpicker
 Requires-Dist: pydata-google-auth
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/spanner_graphs/conversion.py

@@ -76,4 +76,17 @@ def get_nodes_edges(data: Dict[str, List[Any]], fields: List[StructType.Field],
                     edge = Edge.from_json(item)
                     edges.append(edge)
 
+    # Create placeholder nodes for nodes that were not returned
+    # from the query but are identified in the edges
+    missing_node_identifiers = set()
+    for edge in edges:
+        if edge.source not in node_identifiers:
+            missing_node_identifiers.add(edge.source)
+        if edge.destination not in node_identifiers:
+            missing_node_identifiers.add(edge.destination)
+
+    for identifier in missing_node_identifiers:
+        nodes.append(Node.make_intermediate(identifier))
+        node_identifiers.add(identifier)
+
     return nodes, edges

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.4}/spanner_graphs/graph_entities.py

@@ -146,14 +146,16 @@ class Node:
         identifier (str): The unique identifier for the node.
         labels (List[str]): The labels associated with the node.
         properties (Dict[str, Any]): The properties of the node.
+        intermediate (bool): Determines if this node was generated outside of the query response
     """
 
     def __init__(self, identifier: str, labels: List[str],
-                 properties: Dict[str, Any]):
+                 properties: Dict[str, Any], intermediate = False):
         self.identifier = identifier
         self.labels = labels
         self.key_property_names = []
         self.properties = properties
+        self.intermediate = intermediate
 
     def __repr__(self):
         return (f"Node(identifier={self.identifier}, "
@@ -165,9 +167,20 @@ class Node:
             "identifier": self.identifier,
             "labels": self.labels,
             "properties": self.properties,
-            "key_property_names": self.key_property_names
+            "key_property_names": self.key_property_names,
+            "intermediate": self.intermediate
         }
 
+    @staticmethod
+    def make_intermediate(identifier: str):
+        """Create a Node instance in the absence of a node from the query response"""
+        return Node(
+            identifier=identifier,
+            labels=["Intermediate"],
+            properties={"note": "This node represents a referenced entity that wasn't returned in the query results."},
+            intermediate=True
+        )
+
     @classmethod
     def from_json(cls, data: Dict[str, Any]) -> Node:
         """Create a Node instance from a JSON object."""