kodjo/MyFastHtml
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated NetworkVis + unit tests

Browse Source
This commit is contained in:
Kodjo Sossouvi
2025-11-16 19:03:56 +01:00
parent e286b60348
commit 66d5169b41
3 changed files with 775 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/myfasthtml/controls/VisNetwork.py
View File

@@ -1,3 +1,4 @@
import json
import logging
from fasthtml.components import Script, Div
@@ -51,18 +52,17 @@ class VisNetwork(MultipleInstance):
self._state.update(state)
def render(self):
# Prepare JS arrays (no JSON library needed)
# Serialize nodes and edges to JSON
# This preserves all properties (color, shape, size, etc.) that are present
js_nodes = ",\n ".join(
f'{{ id: {n["id"]}, label: "{n.get("label", "")}" }}'
for n in self._state.nodes
json.dumps(node) for node in self._state.nodes
)
js_edges = ",\n ".join(
f'{{ from: {e["from"]}, to: {e["to"]} }}'
for e in self._state.edges
json.dumps(edge) for edge in self._state.edges
)
# Convert Python options to JS
import json
js_options = json.dumps(self._state.options, indent=2)
return (
@@ -73,22 +73,22 @@ class VisNetwork(MultipleInstance):
# The script initializing Vis.js
Script(f"""
(function() {{
const container = document.getElementById("{self._id}");
const nodes = new vis.DataSet([
{js_nodes}
]);
const edges = new vis.DataSet([
{js_edges}
]);
const data = {{
nodes: nodes,
edges: edges
}};
const options = {js_options};
const network = new vis.Network(container, data, options);
}})();
""")
(function() {{
const container = document.getElementById("{self._id}");
const nodes = new vis.DataSet([
{js_nodes}
]);
const edges = new vis.DataSet([
{js_edges}
]);
const data = {{
nodes: nodes,
edges: edges
}};
const options = {js_options};
const network = new vis.Network(container, data, options);
}})();
""")
)
def __ft__(self):

238
src/myfasthtml/core/network_utils.py Normal file
View File

@@ -0,0 +1,238 @@
from collections.abc import Callable
def from_nested_dict(trees: list[dict]) -> tuple[list, list]:
"""
Convert a list of nested dictionaries to vis.js nodes and edges format.
Args:
trees: List of nested dictionaries where keys are node names and values are
dictionaries of children (e.g., [{"root1": {"child1": {}}}, {"root2": {}}])
Returns:
tuple: (nodes, edges) where:
- nodes: list of dicts with auto-incremented numeric IDs
- edges: list of dicts with 'from' and 'to' keys
Example:
>>> trees = [{"root1": {"child1": {}}}, {"root2": {"child2": {}}}]
>>> nodes, edges = from_nested_dict(trees)
>>> # nodes = [{"id": 1, "label": "root1"}, {"id": 2, "label": "child1"}, ...]
"""
nodes = []
edges = []
node_id_counter = 1
node_id_map = {} # maps node_label -> node_id
def traverse(subtree: dict, parent_id: int | None = None):
nonlocal node_id_counter
for node_label, children in subtree.items():
# Create node with auto-incremented ID
current_id = node_id_counter
node_id_map[node_label] = current_id
nodes.append({
"id": current_id,
"label": node_label
})
node_id_counter += 1
# Create edge from parent to current node
if parent_id is not None:
edges.append({
"from": parent_id,
"to": current_id
})
# Recursively process children
if children:
traverse(children, parent_id=current_id)
# Process each tree in the list
for tree in trees:
traverse(tree)
return nodes, edges
def from_tree_with_metadata(
trees: list[dict],
id_getter: Callable = None,
label_getter: Callable = None,
children_getter: Callable = None
) -> tuple[list, list]:
"""
Convert a list of trees with metadata to vis.js nodes and edges format.
Args:
trees: List of dictionaries with 'id', 'label', and 'children' keys
(e.g., [{"id": "root1", "label": "Root 1", "children": [...]}, ...])
id_getter: Optional callback to extract node ID from dict
Default: lambda n: n.get("id")
label_getter: Optional callback to extract node label from dict
Default: lambda n: n.get("label", "")
children_getter: Optional callback to extract children list from dict
Default: lambda n: n.get("children", [])
Returns:
tuple: (nodes, edges) where:
- nodes: list of dicts with IDs from tree or auto-incremented
- edges: list of dicts with 'from' and 'to' keys
Example:
>>> trees = [
... {
... "id": "root1",
... "label": "Root Node 1",
... "children": [
... {"id": "child1", "label": "Child 1", "children": []}
... ]
... },
... {"id": "root2", "label": "Root Node 2"}
... ]
>>> nodes, edges = from_tree_with_metadata(trees)
"""
# Default getters
if id_getter is None:
id_getter = lambda n: n.get("id")
if label_getter is None:
label_getter = lambda n: n.get("label", "")
if children_getter is None:
children_getter = lambda n: n.get("children", [])
nodes = []
edges = []
node_id_counter = 1
def traverse(node_dict: dict, parent_id: int | str | None = None):
nonlocal node_id_counter
# Extract ID (use provided or auto-increment)
node_id = id_getter(node_dict)
if node_id is None:
node_id = node_id_counter
node_id_counter += 1
# Extract label
node_label = label_getter(node_dict)
# Create node
nodes.append({
"id": node_id,
"label": node_label
})
# Create edge from parent to current node
if parent_id is not None:
edges.append({
"from": parent_id,
"to": node_id
})
# Recursively process children
children = children_getter(node_dict)
if children:
for child in children:
traverse(child, parent_id=node_id)
# Process each tree in the list
for tree in trees:
traverse(tree)
return nodes, edges
def from_parent_child_list(
items: list,
id_getter: callable = None,
label_getter: callable = None,
parent_getter: callable = None,
ghost_color: str = "#ff9999"
) -> tuple[list, list]:
"""
Convert a list of items with parent references to vis.js nodes and edges format.
Args:
items: List of items (dicts or objects) with parent references
(e.g., [{"id": "child", "parent": "root", "label": "Child"}, ...])
id_getter: Optional callback to extract node ID from item
Default: lambda item: item.get("id")
label_getter: Optional callback to extract node label from item
Default: lambda item: item.get("label", "")
parent_getter: Optional callback to extract parent ID from item
Default: lambda item: item.get("parent")
ghost_color: Color to use for ghost nodes (nodes referenced as parents but not in list)
Default: "#ff9999" (light red)
Returns:
tuple: (nodes, edges) where:
- nodes: list of dicts with IDs from items, ghost nodes have color property
- edges: list of dicts with 'from' and 'to' keys
Note:
- Nodes with parent=None or parent="" are treated as root nodes
- If a parent is referenced but doesn't exist in items, a ghost node is created
with the ghost_color applied
Example:
>>> items = [
... {"id": "root", "label": "Root"},
... {"id": "child1", "parent": "root", "label": "Child 1"},
... {"id": "child2", "parent": "unknown", "label": "Child 2"}
... ]
>>> nodes, edges = from_parent_child_list(items)
>>> # "unknown" will be created as a ghost node with color="#ff9999"
"""
# Default getters
if id_getter is None:
id_getter = lambda item: item.get("id")
if label_getter is None:
label_getter = lambda item: item.get("label", "")
if parent_getter is None:
parent_getter = lambda item: item.get("parent")
nodes = []
edges = []
# Track all existing node IDs
existing_ids = set()
# First pass: create nodes for all items
for item in items:
node_id = id_getter(item)
node_label = label_getter(item)
existing_ids.add(node_id)
nodes.append({
"id": node_id,
"label": node_label
})
# Track ghost nodes to avoid duplicates
ghost_nodes = set()
# Second pass: create edges and identify ghost nodes
for item in items:
node_id = id_getter(item)
parent_id = parent_getter(item)
# Skip if no parent or parent is empty string or None
if parent_id is None or parent_id == "":
continue
# Create edge from parent to child
edges.append({
"from": parent_id,
"to": node_id
})
# Check if parent exists, if not create ghost node
if parent_id not in existing_ids and parent_id not in ghost_nodes:
ghost_nodes.add(parent_id)
nodes.append({
"id": parent_id,
"label": str(parent_id), # Use ID as label for ghost nodes
"color": ghost_color
})
return nodes, edges