spanner-graph-notebook 1.0.0__py3-none-any.whl

templates/spanner-graph/models/schema.js

@@ -0,0 +1,327 @@
+/**
+ * Represents the schema of the data.
+ * @class
+ */
+class Schema {
+    /**
+     * @typedef {Object} PropertyDefinition
+     * @property {string} propertyDeclarationName
+     * @property {string} valueExpressionSql
+     * @property {string} nodeTableName
+     */
+
+    /**
+     * @typedef {Object} EdgeDestinationNode
+     * @property {Array<string>} edgeTableColumns
+     * @property {Array<string>} nodeTableColumns
+     * @property {string} nodeTableName
+     */
+
+    /**
+     * @typedef {Object} EdgeTable
+     * @property {string} baseCatalogName
+     * @property {string} baseSchemaName
+     * @property {string} baseTableName
+     * @property {EdgeDestinationNode} destinationNodeTable
+     * @property {Array<string>} keyColumns
+     * @property {string} kind
+     * @property {Array<string>} labelNames
+     * @property {string} name
+     * @property {Array<PropertyDefinition>} propertyDefinitions
+     * @property {EdgeDestinationNode} sourceNodeTable
+     */
+
+    /**
+     * @typedef {Object} NodeTable
+     * @property {string} baseCatalogName
+     * @property {string} baseSchemaName
+     * @property {string} baseTableName
+     * @property {Array<string>} keyColumns
+     * @property {string} kind
+     * @property {Array<string>} labelNames
+     * @property {string} name
+     * @property {Array<PropertyDefinition>} propertyDefinitions
+     */
+
+    /**
+     * @typedef PropertyDeclarationType
+     * @param {'INT64'|'STRING'|'FLOAT64'|'TIMESTAMP'|'BOOL'}
+     */
+
+    /**
+     * @type {PropertyDeclarationType}
+     */
+    propertyDeclarationTypes = [
+        'INT64', 'STRING', 'FLOAT64', 'TIMESTAMP', 'BOOL'
+    ];
+
+    /**
+     * @typedef PropertyDeclaration
+     * @param {string} name
+     * @param {PropertyDeclarationType} type
+     */
+
+    /**
+     * @typedef {Object} RawSchema The raw schema object returned from Cloud Spanner
+     * @property {string} catalog
+     * @property {Array<EdgeTable>} edgeTables
+     * @property {number} labels
+     * @property {string} name
+     * @property {Array<NodeTable>} nodeTables
+     * @property {Array<PropertyDeclaration>} propertyDeclarations
+     * @property {string} schema
+     */
+
+    /**
+     * @type {RawSchema}
+     */
+    rawSchema;
+
+    /**
+     * @param {RawSchema} rawSchemaObject
+     */
+    constructor(rawSchemaObject) {
+        this.rawSchema = rawSchemaObject;
+    }
+
+    /**
+     * @param {Array<EdgeTable|NodeTable>} tables
+     * @returns {Array<string>}
+     */
+    getNamesOfTables(tables) {
+         const names = {};
+
+        if (!this.rawSchema) {
+            console.error('No schema found');
+            return [];
+        }
+
+        for (let i = 0; i < tables.length; i++) {
+            const table = tables[i];
+
+            if (!table.name) {
+                console.error('name of nodeTable is not declared');
+                continue;
+            }
+
+            if (typeof table.name != 'string') {
+                console.error('name of nodeTable is not a string');
+                continue;
+            }
+
+            names[table.name] = '';
+        }
+
+        return Object.keys(names);
+    }
+
+    /**
+     * We are only returning the first label as a stopgap
+     * until the Spanner Backend settles on a solution.
+     * @param {Array<EdgeTable|NodeTable>} tables
+     * @returns {Array<string>}
+     */
+    getUniqueLabels(tables) {
+        /**
+         * @type {Array<string>}
+         */
+        const labels = [];
+
+        for (let i = 0; i < tables.length; i++) {
+            const table = tables[i];
+            if (!(table instanceof Object) ||
+                !(table.labelNames instanceof Array) ||
+                table.labelNames.length === 0) {
+                continue;
+            }
+
+            labels.push(tables[i].labelNames[0]);
+        }
+
+        return labels;
+    }
+
+    /**
+     * @returns {Array<string>}
+     */
+    getNodeNames() {
+        return this.getUniqueLabels(this.rawSchema.nodeTables);
+    }
+
+    /**
+     * @returns {Array<string>}
+     */
+    getEdgeNames() {
+        return this.getUniqueLabels(this.rawSchema.edgeTables);
+    }
+
+    /**
+     * @returns {{nodes: Array<string>, edges: Array<string>}}
+     */
+    getTableNames() {
+        return {
+            edges: this.getEdgeNames(),
+            nodes: this.getNodeNames()
+        };
+    }
+
+    /**
+     * @param {EdgeTable|NodeTable} table
+     * @returns {{name: string, type: PropertyDeclarationType}} The keys are the property names, and the values are the value types (int, float, etc.)
+     */
+    getPropertiesOfTable(table){
+        const properties = {}
+
+        const getPropertyType = (name) => {
+            for (let j = 0; j < this.rawSchema.propertyDeclarations.length; j++) {
+                const declaration = this.rawSchema.propertyDeclarations[j];
+                if (declaration.name === name) {
+                    return declaration.type;
+                }
+            }
+        }
+
+        for (let i = 0; i < table.propertyDefinitions.length; i++) {
+            const propertyDefinition = table.propertyDefinitions[i];
+
+            const propertyType = getPropertyType(propertyDefinition.propertyDeclarationName);
+
+            if (!propertyType) {
+                console.error(`Property Declaration does not contain Property Definition: ${propertyDefinition.propertyDeclarationName}`);
+                continue;
+            }
+
+            properties[propertyDefinition.propertyDeclarationName] = propertyType;
+        }
+
+        return properties;
+    }
+
+    /**
+     * @param {NodeTable} nodeTable
+     * @returns {Array<EdgeTable>} Edges
+     */
+    getEdgesOfNode(nodeTable){
+        return this.rawSchema.edgeTables.filter(edgeTable =>
+            edgeTable.sourceNodeTable.nodeTableName === nodeTable.name ||
+            edgeTable.destinationNodeTable.nodeTableName === nodeTable.name);
+    }
+
+    /**
+     * @param edgeTable
+     * @returns {{
+     *     to: NodeTable
+     *     from: NodeTable
+     * }}
+     */
+    getNodesOfEdges(edgeTable) {
+        /**
+         * @type {{to: {nodeTable}, from: {nodeTable}}}
+         */
+        const nodes = {};
+        for (let i = 0; i < this.rawSchema.nodeTables.length; i++) {
+            const nodeTable = this.rawSchema.nodeTables[i];
+            if (edgeTable.sourceNodeTable.nodeTableName === nodeTable.name) {
+                nodes.from = nodeTable;
+            }
+
+            if (edgeTable.destinationNodeTable.nodeTableName === nodeTable.name) {
+                nodes.to = nodeTable;
+            }
+
+            if (nodes.from && nodes.to) {
+                break;
+            }
+        }
+
+        if (!nodes.to || !nodes.from) {
+            console.error('EdgeTable does not have a source or destination node', edgeTable);
+        }
+
+        return nodes;
+    }
+
+    /**
+     * @param {String} name
+     * @returns {EdgeTable}
+     */
+    getEdgeFromName(name) {
+        const edges = this.rawSchema.edgeTables.filter(edgeTable =>
+            edgeTable.name === name);
+
+        if (edges.length > 0) {
+            return edges[0];
+        }
+
+        console.error(`No edgeTable associated with name ${name}`);
+    }
+
+    /**
+     * @param {String} name
+     * @returns {NodeTable}
+     */
+    getNodeFromName(name) {
+        const nodes = this.rawSchema.nodeTables.filter(nodeTable =>
+            nodeTable.name === name);
+
+        if (nodes.length > 0) {
+            return nodes[0];
+        }
+
+        console.error(`No nodeTable associated with name ${name}`);
+    }
+
+    /**
+     * @param {EdgeTable} edgeTable
+     * @returns {number}
+     */
+    getEdgeTableId(edgeTable) {
+        return this.rawSchema.edgeTables.indexOf(edgeTable);
+    }
+
+    /**
+     * @param {NodeTable} nodeTable
+     * @returns {number}
+     */
+    getNodeTableId(nodeTable) {
+        return this.rawSchema.nodeTables.indexOf(nodeTable);
+    }
+
+    /**
+     * @param {String} nodeName
+     * @param {String} edgeName
+     * @returns {{isConnected: Boolean, isSource: Boolean}}
+     */
+    nodeIsConnectedToEdge(nodeName, edgeName) {
+        const connection = {
+            isConnected: false,
+            isSource: false
+        };
+
+        const node = this.getNodeFromName(nodeName);
+        if (!node) {
+            console.error(`No node found from name ${nodeName}`);
+            return connection;
+        }
+
+        const edge = this.getEdgeFromName(edgeName);
+        if (!edge) {
+            console.error(`No edge found from name ${edgeName}`);
+            return connection;
+        }
+
+        connection.isConnected = true;
+        connection.isSource = edge.sourceNodeTable.nodeTableName === node.name
+        return connection;
+    }
+
+    /**
+     * @param {NodeTable|EdgeTable} table
+     * @return {string}
+     */
+    getDisplayName(table) {
+        return table.labelNames[0];
+    }
+}
+
+window[namespace].Schema = Schema;

templates/spanner-graph/spanner-config.js

@@ -0,0 +1,304 @@
+/**
+ * Copyright 2024 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class GraphConfig {
+
+    /**
+     * The array of node objects to be rendered. 123123123
+     * @type {Schema}
+     */
+    schema = null;
+
+    /**
+     * The array of node objects to be rendered.
+     * @type {Array<Node>}
+     */
+    schemaNodes = [];
+
+    /**
+     * The array of edge objects to be rendered.
+     * @type {Array<Edge>}
+     */
+    schemaEdges = [];
+
+    /**
+     * The array of node objects to be rendered.
+     * @type {Array<Node>}
+     */
+    nodes = [];
+
+    /**
+     * The array of edge objects to be rendered.
+     * @type {Array<Edge>}
+     */
+    edges = [];
+
+    /**
+     * Raw data of rows from Spanner Graph
+     * @type {Array<any>}
+     */
+    rowsData = [];
+
+    /**
+     * The currently focused GraphObject. This is usually the
+     * node or edge that the user is hovering their mouse over.
+     * @type {GraphObject}
+     * @default null
+     */
+    focusedGraphObject = null;
+
+    /**
+     * The currently selected GraphObject. This is usually
+     * the node or edge that the user has clicked on.
+     * @type {GraphObject}
+     * @default null
+     */
+    selectedGraphObject = null;
+
+    /**
+     * The color scheme to use for nodes.
+     * @type {GraphConfig.ColorScheme}
+     * @default GraphConfig.ColorScheme.NEIGHBORHOOD
+     */
+    colorScheme = GraphConfig.ColorScheme.NEIGHBORHOOD;
+
+    colorPalette = [
+        '#1A73E8', '#E52592', '#12A4AF', '#F4511E',
+        '#9334E6', '#689F38', '#3949AB', '#546E7A',
+        '#EF6C00', '#D93025', '#1E8E3E', '#039BE5'
+    ];
+
+    // [label: string]: colorString
+    nodeColors = {};
+    // [label: string]: colorString
+    schemaNodeColors = {};
+
+    edgeDesign = {
+        default: {
+            color: '#DADCE0',
+            width: 2,
+            shadowWidth: 0,
+            shadowColor: '#000000'
+        },
+        focused: {
+            color: '#80868B',
+            width: 4,
+            shadowWidth: 6,
+            shadowColor: '#E8EAED'
+        },
+        selected: {
+            color: '#1A73E8',
+            width: 4,
+            shadowWidth: 8,
+            shadowColor: 'rgba(26, 115, 232, 0.25)'
+        }
+    };
+
+    static ColorScheme = Object.freeze({
+        NEIGHBORHOOD: Symbol('neighborhood'),
+        LABEL: Symbol('label')
+    });
+
+    /**
+     * Constructs a new GraphConfig instance.
+     * @constructor
+     * @param {Object} config - The configuration object.
+     * @param {Array} config.nodesData - An array of data objects for nodes.
+     * @param {Array} config.edgesData - An array of data objects for edges.
+     * @param {Array} [config.colorPalette] - An optional array of colors to use as the color palette.
+     * @param {GraphConfig.ColorScheme} [config.colorScheme] - Color scheme can be optionally declared.
+     * @param {Array} [config.rowsData] - Raw row data from Spanner
+     * @param {RawSchema} config.schemaData - Raw schema data from Spanner
+     */
+    constructor({ nodesData, edgesData, colorPalette, colorScheme, rowsData, schemaData}) {
+        this.nodes = this.parseNodes(nodesData);
+        this.edges = this.parseEdges(edgesData);
+        this.nodeColors = this.assignColors(this.nodes);
+        this.parseSchema(schemaData);
+
+        if (colorPalette && Array.isArray(colorPalette)) {
+            this.colorPalette = colorPalette;
+        }
+
+        if (colorScheme) {
+            this.colorScheme = colorScheme;
+        }
+
+        this.rowsData = rowsData;
+    }
+
+    /**
+     * @param nodes
+     * @returns {{}} Color map by the node's label
+     */
+    assignColors(nodes) {
+        const colors = {};
+        const colorPalette = this.colorPalette.map(color => color);
+
+        if (!nodes || !nodes instanceof Array) {
+            console.error('Nodes must be array', nodes);
+            throw Error('Nodes must be an array');
+        }
+
+        nodes.forEach(node => {
+            if (colorPalette.length === 0) {
+                console.error('Node labels exceed the color palette. Assigning default color.');
+                return;
+            }
+
+            if (!node || !node instanceof Node) {
+                console.error('Object is not an instance of Node', node);
+                return;
+            }
+
+            const label = node.label;
+            if (!label || !label instanceof String) {
+                console.error('Node does not have a label', node);
+                return;
+            }
+
+            if (!colors[label]) {
+                colors[label] = colorPalette.shift();
+            }
+        });
+
+        return colors;
+    }
+
+    /**
+     * Parses schema data into nodes and edges
+     * @param {RawSchema} schemaData - The raw data representing a schema
+     * @throws {Error} Throws an error if the schema data can not be parsed
+     */
+    parseSchema(schemaData) {
+        this.schema = new Schema(schemaData);
+
+        const nodesData = this.schema.rawSchema.nodeTables.map(
+            /**
+             * @param {NodeTable} nodeTable
+             * @returns {NodeData}
+             */
+            (nodeTable, i) => {
+                const name = this.schema.getDisplayName(nodeTable)
+
+                /**
+                 * @type {NodeData}
+                 */
+                return {
+                    label: name,
+                    properties: this.schema.getPropertiesOfTable(nodeTable),
+                    color: 'rgb(0, 0, 100)', // this isn't used
+                    key_property_names: ['id'],
+                    id: this.schema.getNodeTableId(nodeTable)
+                };
+            }
+        );
+        this.schemaNodes = this.parseNodes(nodesData);
+
+        const edgesData = this.schema.rawSchema.edgeTables.map(
+            /**
+             * @param {EdgeTable} edgeTable
+             * @returns {EdgeData}
+             */
+            (edgeTable, i) => {
+                const connectedNodes = this.schema.getNodesOfEdges(edgeTable);
+                const name = this.schema.getDisplayName(edgeTable)
+
+                /**
+                 * @type {EdgeData}
+                 */
+                return {
+                    label: name,
+                    properties: this.schema.getPropertiesOfTable(edgeTable),
+                    color: 'rgb(0, 0, 100)', // this isn't used
+                    to: this.schema.getNodeTableId(connectedNodes.to),
+                    from: this.schema.getNodeTableId(connectedNodes.from),
+                    key_property_names: ['id'],
+                    id: this.schema.getEdgeTableId(edgeTable)
+                };
+        });
+        this.schemaEdges = this.parseEdges(edgesData);
+        this.schemaNodeColors = this.assignColors(this.schemaNodes);
+    }
+
+    /**
+     * Parses an array of node data, instantiates nodes, and adds them to the graph.
+     * @param {Array<NodeData>} nodesData - An array of objects representing the data for each node.
+     * @throws {Error} Throws an error if `nodesData` is not an array.
+     */
+    parseNodes(nodesData) {
+        if (!Array.isArray(nodesData)) {
+            console.error('Nodes must be an array', nodesData)
+            throw Error('Nodes must be an array');
+        }
+
+        /** @type {Node[]} */
+        const nodes = []
+        nodesData.forEach(nodeData => {
+            if (!(nodeData instanceof Object)) {
+                console.error('Node data is not an object', nodeData);
+                return;
+            }
+
+            // Try to create a Node
+            const node = new Node(nodeData);
+            if (!node || !node.instantiated) {
+                console.error('Unable to instantiate node', node.instantiationErrorReason);
+                return;
+            }
+            if (node instanceof Node) {
+                nodes.push(node);
+            } else {
+                node.instantiationErrorReason = 'Could not construct an instance of Node';
+                console.error(node.instantiationErrorReason, { nodeData, node });
+            }
+        });
+
+        return nodes;
+    }
+
+    parseEdges(edgesData) {
+        if (!Array.isArray(edgesData)) {
+            console.error('Edges must be an array', edgesData)
+            throw Error('Edges must be an array');
+        }
+
+        /** @type {Edge[]} */
+        const edges = []
+        edgesData.forEach(edgeData => {
+            if (!(edgeData instanceof Object)) {
+                console.error('Edge data is not an object', edgeData);
+                return;
+            }
+
+            // Try to create an Edge
+            const edge = new Edge(edgeData);
+            if (!edge || !edge.instantiated) {
+                console.error('Unable to instantiate edge', edge.instantiationErrorReason);
+                return;
+            }
+            if (edge instanceof Edge) {
+                edges.push(edge);
+            } else {
+                edge.instantiationErrorReason = 'Could not construct an instance of Edge';
+                console.error(edge.instantiationErrorReason, { edgeData, edge });
+            }
+        });
+
+        return edges;
+    }
+}
+
+window[namespace].GraphConfig = GraphConfig;