anywidget-graph 0.2.7__tar.gz → 0.2.8__tar.gz

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anywidget-graph
-Version: 0.2.7
+Version: 0.2.8
 Summary: Interactive graph visualization for Python notebooks using anywidget
 Project-URL: Homepage, https://grafeo.dev/
 Project-URL: Repository, https://github.com/GrafeoDB/anywidget-graph
@@ -326,6 +326,7 @@ graph.save_html("graph.html")           # Write HTML to file
 - [anywidget](https://anywidget.dev/), custom Jupyter widgets made easy
 - [Grafeo](https://github.com/GrafeoDB/grafeo), embeddable graph database
 - [grafeo-web](https://github.com/GrafeoDB/grafeo-web), Grafeo in the browser
+- [Playground](https://grafeo.ai), interactive browser playground for Grafeo
 
 ## License
 

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/README.md

@@ -285,6 +285,7 @@ graph.save_html("graph.html")           # Write HTML to file
 - [anywidget](https://anywidget.dev/), custom Jupyter widgets made easy
 - [Grafeo](https://github.com/GrafeoDB/grafeo), embeddable graph database
 - [grafeo-web](https://github.com/GrafeoDB/grafeo-web), Grafeo in the browser
+- [Playground](https://grafeo.ai), interactive browser playground for Grafeo
 
 ## License
 

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anywidget-graph"
-version = "0.2.7"
+version = "0.2.8"
 description = "Interactive graph visualization for Python notebooks using anywidget"
 readme = "README.md"
 license = "Apache-2.0"

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/__init__.py

@@ -3,4 +3,4 @@
 from anywidget_graph.widget import Graph
 
 __all__ = ["Graph"]
-__version__ = "0.2.7"
+__version__ = "0.2.8"

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/backends/grafeo.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from anywidget_graph.converters import (
     get_node_id,
@@ -19,6 +19,14 @@ if TYPE_CHECKING:
 class GrafeoBackend:
     """Backend for Grafeo database connections."""
 
+    _LANGUAGE_METHODS: ClassVar[dict[str, str]] = {
+        "cypher": "execute_cypher",
+        "gremlin": "execute_gremlin",
+        "graphql": "execute_graphql",
+        "sparql": "execute_sparql",
+        "sql": "execute_sql",
+    }
+
     def __init__(self, db: Any) -> None:
         """Initialize with a GrafeoDB instance."""
         self._db = db
@@ -30,7 +38,11 @@ class GrafeoBackend:
 
     def execute(self, query: str, *, language: str = "cypher") -> tuple[list[dict], list[dict]]:
         """Execute a query in the specified language and return (nodes, edges)."""
-        result = self._db.execute(query)
+        method_name = self._LANGUAGE_METHODS.get(language)
+        if method_name and hasattr(self._db, method_name):
+            result = getattr(self._db, method_name)(query)
+        else:
+            result = self._db.execute(query)
         return self._process_result(result)
 
     def fetch_schema(self) -> tuple[list[dict], list[dict]]:
@@ -61,7 +73,14 @@ class GrafeoBackend:
         for record in records:
             items = self._extract_items(record)
             for _key, value in items:
-                if is_node(value):
+                if self._is_grafeo_node(value):
+                    node_dict = self._grafeo_node_to_dict(value)
+                    node_id = node_dict["id"]
+                    if node_id not in nodes:
+                        nodes[node_id] = node_dict
+                elif self._is_grafeo_relationship(value):
+                    edges.append(self._grafeo_relationship_to_dict(value))
+                elif is_node(value):
                     node_id = get_node_id(value)
                     if node_id not in nodes:
                         nodes[node_id] = node_to_dict(value)
@@ -70,6 +89,45 @@ class GrafeoBackend:
 
         return list(nodes.values()), edges
 
+    @staticmethod
+    def _is_grafeo_node(obj: Any) -> bool:
+        """Check if a value is a Grafeo node dict (has ``_id`` and ``_labels``)."""
+        return isinstance(obj, dict) and "_id" in obj and "_labels" in obj
+
+    @staticmethod
+    def _is_grafeo_relationship(obj: Any) -> bool:
+        """Check if a value is a Grafeo relationship dict (has ``_source``, ``_target``, ``_type``)."""
+        return isinstance(obj, dict) and "_source" in obj and "_target" in obj and "_type" in obj
+
+    @staticmethod
+    def _grafeo_node_to_dict(node: dict) -> dict:
+        """Convert a Grafeo node dict to the widget node format."""
+        node_id = str(node["_id"])
+        labels = node.get("_labels", [])
+        result: dict = {"id": node_id}
+        if labels:
+            result["label"] = labels[0]
+            result["labels"] = list(labels)
+        for key, value in node.items():
+            if not key.startswith("_"):
+                result[key] = value
+        if "label" not in result and "name" in result:
+            result["label"] = result["name"]
+        return result
+
+    @staticmethod
+    def _grafeo_relationship_to_dict(rel: dict) -> dict:
+        """Convert a Grafeo relationship dict to the widget edge format."""
+        result: dict = {
+            "source": str(rel["_source"]),
+            "target": str(rel["_target"]),
+            "label": str(rel["_type"]),
+        }
+        for key, value in rel.items():
+            if not key.startswith("_"):
+                result[key] = value
+        return result
+
     def _extract_items(self, record: Any) -> list[tuple[str, Any]]:
         """Extract key-value items from a record."""
         if hasattr(record, "items"):

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/ui/__init__.py

@@ -140,6 +140,7 @@ def get_esm() -> str:
     schema_js = _read_file(_UI_DIR / "schema.js")
     settings_js = _read_file(_UI_DIR / "settings.js")
     properties_js = _read_file(_UI_DIR / "properties.js")
+    results_js = _read_file(_UI_DIR / "results.js")
     toolbar_js = _read_file(_UI_DIR / "toolbar.js")
     index_js = _read_file(_UI_DIR / "index.js")
 
@@ -173,6 +174,9 @@ import neo4j from "https://cdn.jsdelivr.net/npm/neo4j-driver@5.28.0/lib/browser/
 // === Properties Panel ===
 {_strip_imports_exports(properties_js)}
 
+// === Results Drawer ===
+{_strip_imports_exports(results_js)}
+
 // === Toolbar ===
 {_resolve_namespaces(toolbar_js)}
 

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/ui/icons.js

@@ -16,4 +16,6 @@ export const ICONS = {
   zoomOut: `<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/><line x1="8" y1="11" x2="14" y2="11"/></svg>`,
   zoomFit: `<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7"/></svg>`,
   search: `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>`,
+  chevronUp: `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 15l-6-6-6 6"/></svg>`,
+  table: `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="3" width="18" height="18" rx="2"/><path d="M3 9h18M3 15h18M9 3v18"/></svg>`,
 };

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/ui/index.js

@@ -9,6 +9,7 @@ import { createToolbar } from "./toolbar.js";
 import { createSchemaPanel } from "./schema.js";
 import { createSettingsPanel } from "./settings.js";
 import { createPropertiesPanel } from "./properties.js";
+import { createResultsDrawer } from "./results.js";
 import * as neo4jBackend from "./neo4j.js";
 import * as grafeoBackend from "./grafeo.js";
 import * as grafeoEmbedBackend from "./grafeo-embed.js";
@@ -168,6 +169,8 @@ async function executeQuery(model) {
     return;
   }
 
+  const start = performance.now();
+
   if (backend === "neo4j") {
     // Browser-side Neo4j driver
     const result = await neo4jBackend.executeQuery(
@@ -176,6 +179,7 @@ async function executeQuery(model) {
       model
     );
     if (result) {
+      model.set("query_time", performance.now() - start);
       model.set("nodes", result.nodes);
       model.set("edges", result.edges);
       model.save_changes();
@@ -189,6 +193,7 @@ async function executeQuery(model) {
       model
     );
     if (result) {
+      model.set("query_time", performance.now() - start);
       model.set("nodes", result.nodes);
       model.set("edges", result.edges);
       model.save_changes();
@@ -197,12 +202,14 @@ async function executeQuery(model) {
     // Browser-side Grafeo WASM
     const result = await grafeoEmbedBackend.executeQuery(query, language, model);
     if (result) {
+      model.set("query_time", performance.now() - start);
       model.set("nodes", result.nodes);
       model.set("edges", result.edges);
       model.save_changes();
     }
   } else {
     // Python-side backends (grafeo-embedded, ladybug, arango, cosmosdb)
+    // Timing is handled on the Python side
     model.set("_execute_query", model.get("_execute_query") + 1);
     model.save_changes();
   }
@@ -283,6 +290,11 @@ function render({ model, el }) {
   }
 
   wrapper.appendChild(content);
+
+  // Results drawer (bottom, hidden by default with lip toggle)
+  const results = createResultsDrawer(model);
+  wrapper.appendChild(results.element);
+
   el.appendChild(wrapper);
 
   // Initialize Graphology graph
@@ -326,6 +338,52 @@ function render({ model, el }) {
       case "random":
         random.assign(graph);
         break;
+      case "cluster": {
+        // Group nodes by first label, arrange clusters in a circle
+        const nodes = model.get("nodes") || [];
+        const labelGroups = new Map();
+        nodes.forEach((node) => {
+          const label = (node.labels && node.labels[0]) || node.label || "__other";
+          if (!labelGroups.has(label)) labelGroups.set(label, []);
+          labelGroups.get(label).push(node.id);
+        });
+
+        const clusterLabels = [...labelGroups.entries()].filter(([, g]) => g.length >= 2);
+        const useClusters = clusterLabels.length >= 2;
+
+        if (!useClusters) {
+          // Not enough clusters, fall back to force
+          applyLayout("force");
+          return;
+        }
+
+        // Collect all labels (clusters with 2+ nodes first, then singles)
+        const singleNodes = [...labelGroups.entries()]
+          .filter(([, g]) => g.length < 2)
+          .flatMap(([, g]) => g);
+        const allGroups = [...clusterLabels];
+        if (singleNodes.length > 0) {
+          allGroups.push(["__other", singleNodes]);
+        }
+
+        const cx = 50, cy = 50;
+        const clusterRadius = 40;
+
+        allGroups.forEach(([, nodeIds], clusterIdx) => {
+          const clusterAngle = (2 * Math.PI * clusterIdx) / allGroups.length;
+          const clusterCx = cx + clusterRadius * Math.cos(clusterAngle);
+          const clusterCy = cy + clusterRadius * Math.sin(clusterAngle);
+          const innerRadius = Math.max(5, Math.min(20, nodeIds.length * 2));
+
+          nodeIds.forEach((nodeId, nodeIdx) => {
+            if (!graph.hasNode(nodeId)) return;
+            const innerAngle = (2 * Math.PI * nodeIdx) / nodeIds.length;
+            graph.setNodeAttribute(nodeId, "x", clusterCx + innerRadius * Math.cos(innerAngle));
+            graph.setNodeAttribute(nodeId, "y", clusterCy + innerRadius * Math.sin(innerAngle));
+          });
+        });
+        break;
+      }
       case "force": {
         const n = graph.order;
         // Scale layout parameters to graph size for good spreading
@@ -469,7 +527,7 @@ function render({ model, el }) {
   const layoutSelect = document.createElement("select");
   layoutSelect.className = "awg-layout-select";
   layoutSelect.title = "Layout algorithm";
-  [["force", "Force"], ["circular", "Circular"], ["random", "Random"]].forEach(([val, text]) => {
+  [["force", "Force"], ["cluster", "Cluster"], ["circular", "Circular"], ["random", "Random"]].forEach(([val, text]) => {
     const opt = document.createElement("option");
     opt.value = val;
     opt.textContent = text;

anywidget_graph-0.2.8/src/anywidget_graph/ui/results.js

@@ -0,0 +1,183 @@
+/**
+ * Results drawer component with collapsible lip toggle.
+ */
+import { ICONS } from "./icons.js";
+
+/**
+ * Create the results drawer (bottom panel with lip toggle).
+ */
+export function createResultsDrawer(model) {
+  const drawer = document.createElement("div");
+  drawer.className = "awg-results-drawer";
+
+  // Lip (always visible, toggles the drawer)
+  const lip = document.createElement("div");
+  lip.className = "awg-results-lip";
+
+  const lipIcon = document.createElement("span");
+  lipIcon.className = "awg-results-lip-icon";
+  lipIcon.innerHTML = ICONS.chevronUp;
+
+  const lipLabel = document.createElement("span");
+  lipLabel.className = "awg-results-lip-label";
+  lipLabel.innerHTML = `${ICONS.table} Results`;
+
+  const lipTiming = document.createElement("span");
+  lipTiming.className = "awg-results-lip-timing";
+
+  function updateLipTiming() {
+    const ms = model.get("query_time") || 0;
+    const nodes = model.get("nodes") || [];
+    const edges = model.get("edges") || [];
+    const parts = [];
+    if (nodes.length > 0 || edges.length > 0) {
+      parts.push(`${nodes.length}n / ${edges.length}e`);
+    }
+    if (ms > 0) {
+      parts.push(ms < 1 ? "<1 ms" : `${ms.toFixed(1)} ms`);
+    }
+    lipTiming.textContent = parts.join(" \u00b7 ");
+  }
+  updateLipTiming();
+  model.on("change:query_time", updateLipTiming);
+  model.on("change:nodes", updateLipTiming);
+  model.on("change:edges", updateLipTiming);
+
+  lip.appendChild(lipLabel);
+  lip.appendChild(lipTiming);
+  lip.appendChild(lipIcon);
+
+  // Body (collapsible)
+  const body = document.createElement("div");
+  body.className = "awg-results-body";
+
+  // Tab bar
+  const tabBar = document.createElement("div");
+  tabBar.className = "awg-results-tabs";
+
+  const nodesTab = document.createElement("button");
+  nodesTab.className = "awg-results-tab awg-results-tab-active";
+  nodesTab.textContent = "Nodes";
+
+  const edgesTab = document.createElement("button");
+  edgesTab.className = "awg-results-tab";
+  edgesTab.textContent = "Edges";
+
+  tabBar.appendChild(nodesTab);
+  tabBar.appendChild(edgesTab);
+  body.appendChild(tabBar);
+
+  // Table container
+  const tableContainer = document.createElement("div");
+  tableContainer.className = "awg-results-table-wrap";
+  body.appendChild(tableContainer);
+
+  let activeTab = "nodes";
+
+  function setActiveTab(tab) {
+    activeTab = tab;
+    nodesTab.classList.toggle("awg-results-tab-active", tab === "nodes");
+    edgesTab.classList.toggle("awg-results-tab-active", tab === "edges");
+    renderTable();
+  }
+
+  nodesTab.addEventListener("click", () => setActiveTab("nodes"));
+  edgesTab.addEventListener("click", () => setActiveTab("edges"));
+
+  function renderTable() {
+    tableContainer.innerHTML = "";
+    const items = model.get(activeTab === "nodes" ? "nodes" : "edges") || [];
+
+    if (items.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "awg-results-empty";
+      empty.textContent = activeTab === "nodes" ? "No nodes" : "No edges";
+      tableContainer.appendChild(empty);
+      return;
+    }
+
+    // Collect all keys across items (skip internal rendering keys)
+    const skipKeys = new Set(["x", "y", "size", "color"]);
+    const keys = [];
+    const seen = new Set();
+    items.forEach((item) => {
+      Object.keys(item).forEach((k) => {
+        if (!seen.has(k) && !skipKeys.has(k)) {
+          seen.add(k);
+          keys.push(k);
+        }
+      });
+    });
+
+    const table = document.createElement("table");
+    table.className = "awg-results-table";
+
+    // Header
+    const thead = document.createElement("thead");
+    const headerRow = document.createElement("tr");
+    keys.forEach((k) => {
+      const th = document.createElement("th");
+      th.textContent = k;
+      headerRow.appendChild(th);
+    });
+    thead.appendChild(headerRow);
+    table.appendChild(thead);
+
+    // Body (limit to 100 rows for performance)
+    const tbody = document.createElement("tbody");
+    const limit = Math.min(items.length, 100);
+    for (let i = 0; i < limit; i++) {
+      const row = document.createElement("tr");
+      keys.forEach((k) => {
+        const td = document.createElement("td");
+        const val = items[i][k];
+        if (val === undefined || val === null) {
+          td.textContent = "";
+        } else if (typeof val === "object") {
+          td.textContent = JSON.stringify(val);
+        } else {
+          td.textContent = String(val);
+        }
+        row.appendChild(td);
+      });
+      tbody.appendChild(row);
+    }
+    table.appendChild(tbody);
+    tableContainer.appendChild(table);
+
+    if (items.length > 100) {
+      const more = document.createElement("div");
+      more.className = "awg-results-empty";
+      more.textContent = `Showing 100 of ${items.length} rows`;
+      tableContainer.appendChild(more);
+    }
+  }
+
+  model.on("change:nodes", () => { if (activeTab === "nodes") renderTable(); });
+  model.on("change:edges", () => { if (activeTab === "edges") renderTable(); });
+  renderTable();
+
+  drawer.appendChild(lip);
+  drawer.appendChild(body);
+
+  let isOpen = false;
+
+  function toggle() {
+    isOpen = !isOpen;
+    drawer.classList.toggle("awg-results-open", isOpen);
+    lipIcon.style.transform = isOpen ? "" : "rotate(180deg)";
+  }
+
+  lip.addEventListener("click", toggle);
+
+  // Start closed
+  lipIcon.style.transform = "rotate(180deg)";
+
+  return {
+    element: drawer,
+    open: () => { if (!isOpen) toggle(); },
+    close: () => { if (isOpen) toggle(); },
+    toggle,
+    isOpen: () => isOpen,
+  };
+}

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/ui/styles.css

@@ -821,6 +821,139 @@
   }
 }
 
+/* === TIMING BADGE === */
+.awg-timing-badge {
+  color: var(--awg-accent);
+  font-size: 11px;
+}
+
+/* === RESULTS DRAWER === */
+.awg-results-drawer {
+  border-top: 1px solid var(--awg-border);
+  background: var(--awg-bg-secondary);
+}
+
+.awg-results-lip {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  height: 28px;
+  cursor: pointer;
+  font-size: 11px;
+  color: var(--awg-text-secondary);
+  user-select: none;
+  transition: background 0.15s;
+}
+
+.awg-results-lip:hover {
+  background: var(--awg-bg-tertiary);
+}
+
+.awg-results-lip-icon {
+  display: flex;
+  transition: transform 0.2s;
+}
+
+.awg-results-lip-label {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.3px;
+}
+
+.awg-results-lip-timing {
+  font-variant-numeric: tabular-nums;
+  color: var(--awg-text-muted);
+}
+
+.awg-results-body {
+  max-height: 0;
+  overflow: hidden;
+  transition: max-height 0.25s ease;
+}
+
+.awg-results-open .awg-results-body {
+  max-height: 220px;
+  overflow-y: auto;
+}
+
+.awg-results-tabs {
+  display: flex;
+  gap: 0;
+  border-bottom: 1px solid var(--awg-border);
+  padding: 0 12px;
+}
+
+.awg-results-tab {
+  padding: 6px 14px;
+  border: none;
+  background: none;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--awg-text-muted);
+  cursor: pointer;
+  border-bottom: 2px solid transparent;
+  transition: color 0.15s, border-color 0.15s;
+}
+
+.awg-results-tab:hover {
+  color: var(--awg-text);
+}
+
+.awg-results-tab-active {
+  color: var(--awg-accent);
+  border-bottom-color: var(--awg-accent);
+}
+
+.awg-results-table-wrap {
+  overflow-x: auto;
+}
+
+.awg-results-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+
+.awg-results-table th {
+  position: sticky;
+  top: 0;
+  background: var(--awg-bg-tertiary);
+  padding: 6px 10px;
+  text-align: left;
+  font-weight: 600;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.3px;
+  color: var(--awg-text-secondary);
+  white-space: nowrap;
+  border-bottom: 1px solid var(--awg-border);
+}
+
+.awg-results-table td {
+  padding: 5px 10px;
+  color: var(--awg-text);
+  border-bottom: 1px solid var(--awg-border);
+  max-width: 200px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.awg-results-table tbody tr:hover {
+  background: var(--awg-bg-tertiary);
+}
+
+.awg-results-empty {
+  padding: 16px;
+  text-align: center;
+  color: var(--awg-text-muted);
+  font-size: 12px;
+}
+
 /* === Touch-Friendly Targets === */
 @media (pointer: coarse) {
   .awg-btn {

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/ui/toolbar.js

@@ -103,6 +103,22 @@ export function createToolbar(model, onExecuteQuery, panels, onSearch) {
   model.on("change:edges", updateCount);
   toolbar.appendChild(countBadge);
 
+  // Query timing badge
+  const timingBadge = document.createElement("span");
+  timingBadge.className = "awg-count-badge awg-timing-badge";
+  function updateTiming() {
+    const ms = model.get("query_time") || 0;
+    if (ms > 0) {
+      timingBadge.textContent = ms < 1 ? "<1 ms" : `${ms.toFixed(1)} ms`;
+      timingBadge.style.display = "";
+    } else {
+      timingBadge.style.display = "none";
+    }
+  }
+  updateTiming();
+  model.on("change:query_time", updateTiming);
+  toolbar.appendChild(timingBadge);
+
   // Settings button (mutual exclusion with properties)
   if (model.get("show_settings")) {
     const settingsBtn = document.createElement("button");

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/src/anywidget_graph/widget.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import time
 from typing import TYPE_CHECKING, Any
 
 import anywidget
@@ -115,6 +116,7 @@ class Graph(anywidget.AnyWidget):
     query = traitlets.Unicode(default_value="").tag(sync=True)
     query_language = traitlets.Unicode(default_value="cypher").tag(sync=True)
     query_running = traitlets.Bool(default_value=False).tag(sync=True)
+    query_time = traitlets.Float(default_value=0.0).tag(sync=True)
     query_error = traitlets.Unicode(default_value="").tag(sync=True)
 
     # === Connection State ===
@@ -271,7 +273,9 @@ class Graph(anywidget.AnyWidget):
         try:
             self.query_running = True
             self.query_error = ""
+            start = time.perf_counter()
             nodes, edges = self._backend.execute(self.query, language=self.query_language)
+            self.query_time = (time.perf_counter() - start) * 1000
             self.nodes = nodes
             self.edges = edges
         except Exception as e:

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/tests/test_graph.py

@@ -55,6 +55,7 @@ def test_default_options():
     assert graph.selection_mode == "click"
     assert graph.database_backend == "grafeo"
     assert graph.max_nodes == 300
+    assert graph.query_time == 0.0
 
 
 def test_custom_options():
@@ -587,3 +588,150 @@ def test_build_neighbor_query_aql():
     q = Graph._build_neighbor_query("doc/1", "aql")
     assert "doc/1" in q
     assert "FOR" in q
+
+
+# ------------------------------------------------------------------ #
+#  Grafeo backend: language dispatch                                   #
+# ------------------------------------------------------------------ #
+
+
+def test_grafeo_backend_language_dispatch():
+    """execute() uses the language-specific method when available."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    calls: list[tuple[str, str]] = []
+
+    class FakeDB:
+        def execute_cypher(self, query):
+            calls.append(("cypher", query))
+            return []
+
+        def execute(self, query):
+            calls.append(("generic", query))
+            return []
+
+    backend = GrafeoBackend(FakeDB())
+    backend.execute("MATCH (n) RETURN n", language="cypher")
+    assert calls[-1] == ("cypher", "MATCH (n) RETURN n")
+
+
+def test_grafeo_backend_language_fallback():
+    """execute() falls back to generic execute for unknown languages."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    calls: list[tuple[str, str]] = []
+
+    class FakeDB:
+        def execute(self, query):
+            calls.append(("generic", query))
+            return []
+
+    backend = GrafeoBackend(FakeDB())
+    backend.execute("SELECT 1", language="sql")
+    assert calls[-1] == ("generic", "SELECT 1")
+
+
+# ------------------------------------------------------------------ #
+#  Grafeo backend: native dict processing                              #
+# ------------------------------------------------------------------ #
+
+
+def test_grafeo_node_detection():
+    """_is_grafeo_node detects dicts with _id and _labels."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    assert GrafeoBackend._is_grafeo_node({"_id": 1, "_labels": ["Person"]})
+    assert not GrafeoBackend._is_grafeo_node({"id": 1, "label": "Person"})
+    assert not GrafeoBackend._is_grafeo_node({"_id": 1})
+    assert not GrafeoBackend._is_grafeo_node("not a dict")
+
+
+def test_grafeo_relationship_detection():
+    """_is_grafeo_relationship detects dicts with _source, _target, _type."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    assert GrafeoBackend._is_grafeo_relationship({"_source": 1, "_target": 2, "_type": "KNOWS"})
+    assert not GrafeoBackend._is_grafeo_relationship({"source": 1, "target": 2, "label": "KNOWS"})
+    assert not GrafeoBackend._is_grafeo_relationship({"_source": 1, "_target": 2})
+
+
+def test_grafeo_node_to_dict():
+    """_grafeo_node_to_dict converts Grafeo node format to widget format."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    node = {"_id": 42, "_labels": ["Person", "Employee"], "name": "Alice", "age": 30}
+    result = GrafeoBackend._grafeo_node_to_dict(node)
+
+    assert result["id"] == "42"
+    assert result["label"] == "Person"
+    assert result["labels"] == ["Person", "Employee"]
+    assert result["name"] == "Alice"
+    assert result["age"] == 30
+    assert "_id" not in result
+    assert "_labels" not in result
+
+
+def test_grafeo_node_to_dict_name_fallback():
+    """_grafeo_node_to_dict uses name as label when no _labels."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    node = {"_id": 1, "_labels": [], "name": "Bob"}
+    result = GrafeoBackend._grafeo_node_to_dict(node)
+    assert result["label"] == "Bob"
+
+
+def test_grafeo_relationship_to_dict():
+    """_grafeo_relationship_to_dict converts Grafeo edge format to widget format."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    rel = {"_source": 1, "_target": 2, "_type": "KNOWS", "since": 2020}
+    result = GrafeoBackend._grafeo_relationship_to_dict(rel)
+
+    assert result["source"] == "1"
+    assert result["target"] == "2"
+    assert result["label"] == "KNOWS"
+    assert result["since"] == 2020
+    assert "_source" not in result
+    assert "_type" not in result
+
+
+def test_grafeo_backend_process_native_dicts():
+    """Full round-trip: backend processes Grafeo native dict results."""
+    from anywidget_graph.backends.grafeo import GrafeoBackend
+
+    class FakeDB:
+        def execute(self, query):
+            return [
+                {
+                    "n": {"_id": 1, "_labels": ["Person"], "name": "Alice"},
+                    "r": {"_source": 1, "_target": 2, "_type": "KNOWS", "since": 2020},
+                    "m": {"_id": 2, "_labels": ["Person"], "name": "Bob"},
+                },
+            ]
+
+    backend = GrafeoBackend(FakeDB())
+    nodes, edges = backend.execute("MATCH (n)-[r]->(m) RETURN n, r, m")
+
+    assert len(nodes) == 2
+    assert len(edges) == 1
+
+    node_ids = {n["id"] for n in nodes}
+    assert node_ids == {"1", "2"}
+
+    assert edges[0]["source"] == "1"
+    assert edges[0]["target"] == "2"
+    assert edges[0]["label"] == "KNOWS"
+    assert edges[0]["since"] == 2020
+
+
+# ------------------------------------------------------------------ #
+#  Query timing                                                        #
+# ------------------------------------------------------------------ #
+
+
+def test_query_time_traitlet():
+    """query_time traitlet defaults to 0.0 and can be set."""
+    graph = Graph()
+    assert graph.query_time == 0.0
+    graph.query_time = 42.5
+    assert graph.query_time == 42.5

{anywidget_graph-0.2.7 → anywidget_graph-0.2.8}/uv.lock

@@ -154,7 +154,7 @@ wheels = [
 
 [[package]]
 name = "anywidget-graph"
-version = "0.2.7"
+version = "0.2.8"
 source = { editable = "." }
 dependencies = [
     { name = "anywidget" },