gismap 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

gismap/__init__.py

@@ -14,6 +14,7 @@ from gismap.search import (
     search_to_html as search_to_html,
     search_to_text as search_to_text,
 )
+from gismap.gisgraphs.widget import GismapWidget as GismapWidget
 
 
 infos = metadata(__name__)

gismap/gisgraphs/builder.py

@@ -0,0 +1,105 @@
+import json
+import uuid
+from domonic import tags
+
+from gismap.gisgraphs.graph import lab_to_graph
+from gismap.gisgraphs.groups import auto_groups
+from gismap.gisgraphs.options import (
+    physics as def_physics,
+    nodes as def_nodes,
+    edges as def_edges,
+    interaction as def_interaction,
+)
+from gismap.gisgraphs.style import default_style
+from gismap.gisgraphs.js import default_script
+from gismap.gisgraphs.groups import make_legend
+
+
+default_vis_url = '"https://unpkg.com/vis-network/standalone/esm/vis-network.min.js"'
+
+gislink = tags.a(
+    "© GisMap 2025",
+    _href="https://balouf.github.io/gismap/",
+    _target="_blank",
+    _class="watermark gislink",
+)
+
+
+def make_vis(lab, **kwargs):
+    """
+    Parameters
+    ----------
+    lab: :class:`~gismap.lab.labmap.LabMap`
+        Lab to display.
+
+    Other parameters
+    ----------------
+    uid: :class:`str`
+        Unique identifier.
+    vis_url: :class:`str`
+        Location of visJS network.
+
+    Returns
+    -------
+    :class:`str`
+        HTML code.
+    """
+    uid = kwargs.pop("uid", None)
+    if uid is None:
+        uid = str(uuid.uuid4())[:8]
+    vis_url = kwargs.pop("vis_url", default_vis_url)
+    groups = kwargs.pop("groups", None)
+    groups = auto_groups(lab, groups)
+    draw_legend = kwargs.pop("draw_legend", len(groups) > 1)
+    physics = kwargs.pop("physics", def_physics)
+    nodes_options = kwargs.pop("nodes_options", def_nodes)
+    edges_options = kwargs.pop("edges_options", def_edges)
+    interaction_options = kwargs.pop("interaction_option", def_interaction)
+    options = {
+        "physics": physics,
+        "groups": groups,
+        "nodes": nodes_options,
+        "edges": edges_options,
+        "interaction": interaction_options,
+    }
+    style = kwargs.pop("style", default_style)
+    script = kwargs.pop("script", default_script)
+    if kwargs:
+        raise TypeError(f"unexpected keyword arguments: {repr(kwargs)}")
+
+    nodes, edges = lab_to_graph(lab)
+
+    parameters = {
+        "vis_url": vis_url,
+        "uid": uid,
+        "nodes": json.dumps(nodes),
+        "edges": json.dumps(edges),
+        "options": json.dumps(options),
+    }
+    div = tags.div(_class="gisgraph", _id=f"box-{uid}")
+    div.appendChild(tags.div(_id=f"vis-{uid}"))
+    div.appendChild(gislink)
+    div.appendChild(
+        tags.button("Redraw()", _id=f"redraw-{uid}", _class="watermark button redraw")
+    )
+    div.appendChild(
+        tags.button(
+            "Full Screen", _id=f"fullscreen-{uid}", _class="watermark button fullscreen"
+        )
+    )
+    comets = not all(n.get("connected") for n in nodes)
+    if draw_legend or comets:
+        div.appendChild(make_legend(groups, uid))
+    modal = tags.div(_class="modal", _id=f"modal-{uid}")
+    modal_content = tags.div(_class="modal-content")
+    modal_content.appendChild(
+        tags.span("×", _class="close", _id=f"modal-close-{uid}")
+    )
+    modal_content.appendChild(tags.div(_id=f"modal-body-{uid}"))
+    modal.appendChild(modal_content)
+    div.appendChild(modal)
+
+    style = tags.style(style.substitute(**parameters))
+    script = tags.script(script.substitute(**parameters), _type="module")
+
+    return "\n".join(f"{content}" for content in [div, style, script])

gismap/{lab → gisgraphs}/graph.py

@@ -1,7 +1,7 @@
-import numpy as np
-from collections import defaultdict
+from domonic import tags
 from itertools import combinations
-from gismap.lab.vis import generate_html
+from collections import defaultdict
+import numpy as np
 
 
 def initials(name):
@@ -17,10 +17,17 @@ def initials(name):
         Person's initials (2 letters only).
     """
     first_letters = [w[0] for w in name.split()]
-    return first_letters[0] + first_letters[-1]
+    return first_letters[0].upper() + first_letters[-1].upper()
+
+
+def linkify(name, url):
+    if url:
+        return f'<a href="{url}" target="_blank">{name}</a>'
+    else:
+        return f"<span>{name}</span>"
 
 
-def author_to_html(author):
+def author_html(author):
     """
     Parameters
     ----------
@@ -41,13 +48,10 @@ def author_to_html(author):
             url = meta_url
         elif hasattr(author.sources[0], "url"):
             url = author.sources[0].url
-    if url:
-        return f'<a href="{url.strip()}" target="_blank">{name}</a>'
-    else:
-        return name
+    return linkify(name, url)
 
 
-def publication_to_html(pub):
+def pub_html(pub):
     """
     Parameters
     ----------
@@ -62,16 +66,12 @@ def publication_to_html(pub):
     url = getattr(pub, "url", None)
     if url is None and hasattr(pub, "sources"):
         url = getattr(pub.sources[0], "url", None)
-    if url:
-        title_html = f'<a href="{url}" target="_blank">{pub.title}</a>'
-    else:
-        title_html = pub.title
+    title_html = linkify(pub.title, url)
 
     # Authors: render in order, separated by comma
-    author_html_list = [
-        author_to_html(author) for author in getattr(pub, "authors", [])
-    ]
-    authors_html = ", ".join(author_html_list)
+    authors_html = ", ".join(
+        [author_html(author) for author in getattr(pub, "authors", [])]
+    )
 
     # Venue, Year
     venue = getattr(pub, "venue", "")
@@ -82,9 +82,14 @@ def publication_to_html(pub):
     return html.strip()
 
 
-def publications_list_html(publications, n=10):
-    """
+expand_script = """var elts = this.parentElement.parentElement.querySelectorAll('.extra-publication');
+for (var i = 0; i < elts.length; ++i) {elts[i].style.display = 'list-item';}
+this.parentElement.style.display = 'none';
+return false;"""
+
 
+def publications_list(publications, n=10):
+    """
     Parameters
     ----------
     publications: :class:`list` of :class:`~gismap.sources.models.Publication`
@@ -94,38 +99,19 @@ def publications_list_html(publications, n=10):
 
     Returns
     -------
-    :class:`str`
+    :class:`~domonic.html.ul`
     """
-    list_items = []
+    lis = []
     for i, pub in enumerate(publications):
-        item = publication_to_html(pub)
         if i < n:
-            li = f"<li>{item}</li>"
+            lis.append(f"<li>{pub_html(pub)}</li>")
         else:
-            li = f'<li class="extra-publication" style="display:none;">{item}</li>'
-        list_items.append(li)
-    ul_content = "\n".join(list_items)
-
-    if len(publications) <= n:
-        show_more_part = ""
-    else:
-        # Add a "Show more" link and JavaScript for toggling
-        show_more_part = """
-<li>
-  <a href="#" onclick="
-    var elts = this.parentElement.parentElement.querySelectorAll('.extra-publication');
-    for (var i = 0; i < elts.length; ++i) {elts[i].style.display = 'list-item';}
-    this.parentElement.style.display = 'none';
-    return false;">Show more…</a>
-</li>
-        """
-
-    html = f"""<ul>
-{ul_content}
-{show_more_part}
-</ul>
-"""
-    return html
+            lis.append(
+                f'<li class="extra-publication" style="display:none;">{pub_html(pub)}</li>'
+            )
+    if len(publications) > n:
+        lis.append(f'<li><a href="#" onclick="{expand_script}">Show more…</a></li>')
+    return "<ul>\n" + "\n".join(lis) + "</ul>\n"
 
 
 def to_node(s, node_pubs):
@@ -142,10 +128,14 @@ def to_node(s, node_pubs):
     :class:`dict`
         A display-ready representation of the searcher.
     """
+    overlay = tags.div()
+    overlay.appendChild(tags.div(f"Publications of {author_html(s)}"))
+    overlay.appendChild(tags.div(publications_list(node_pubs[s.key])))
+
     res = {
         "id": s.key,
         "hover": f"Click for details on {s.name}.",
-        "overlay": f"<div> Publications of {author_to_html(s)}:</div><div>{publications_list_html(node_pubs[s.key])}</div>",
+        "overlay": f"{overlay}",
         "group": s.metadata.group,
     }
     if s.metadata.img:
@@ -175,17 +165,28 @@ def to_edge(k, v, searchers):
         A display-ready representation of the collaboration edge.
     """
     strength = 1 + np.log2(len(v))
-    return {
+    overlay = tags.div()
+    overlay.appendChild(
+        tags.div(
+            f"Joint publications from {author_html(searchers[k[0]])} and {author_html(searchers[k[1]])}:"
+        )
+    )
+    overlay.appendChild(tags.div(f"{publications_list(v)}"))
+    res = {
         "from": k[0],
         "to": k[1],
         "hover": f"Show joint publications from {searchers[k[0]].name} and {searchers[k[1]].name}",
-        "overlay": f"<div> Joint publications from {author_to_html(searchers[k[0]])} and {author_to_html(searchers[k[1]])}:</div><div>{publications_list_html(v)}</div>",
+        "overlay": f"{overlay}",
         "width": int(strength),
         "length": int(200 / strength),
     }
+    g1, g2 = searchers[k[0]].metadata.group, searchers[k[1]].metadata.group
+    if g1 and g2 and g1 != g2:
+        res["color"] = "rgba(0,0,0,0)"
+    return res
 
 
-def lab2graph(lab):
+def lab_to_graph(lab):
     """
     Parameters
     ----------
@@ -201,18 +202,21 @@ def lab2graph(lab):
     --------
 
     >>> from gismap.lab import ListMap as Map
-    >>> lab = Map(author_list=['Tixeuil Sébastien', 'Mathieu Fabien'], name='mini')
+    >>> lab = Map(author_list=['Tixeuil Sébastien', 'Mathieu Fabien'], name='mini', dbs="hal")
     >>> lab.update_authors()
     >>> lab.update_publis()
     >>> len(lab.authors)
     2
-    >>> 380 < len(lab.publications) < 440
+    >>> 330 < len(lab.publications) < 430
     True
-    >>> html = lab2graph(lab)
-    >>> html[:80]  # doctest: +ELLIPSIS
-    '\\n<div class="gismap-content">\\n<div id="mynetwork_..."></div>\\n<a\\n  href="htt'
+    >>> nodes, edges = lab_to_graph(lab)
+    >>> nodes[0]['group']
+    'mini'
+    >>> edges[0]['hover']
+    'Show joint publications from Mathieu Fabien and Tixeuil Sébastien'
+    >>> html = lab.html(groups={"mini": {"color": "#777"}})
     """
-    node_pubs = {k: [] for k in lab.authors}
+    node_pubs = defaultdict(list)  # {k: [] for k in lab.authors}
     edges_dict = defaultdict(list)
     for p in lab.publications.values():
         # Strange things can happen with multiple sources. This should take care of it.
@@ -228,16 +232,16 @@ def lab2graph(lab):
         for a1, a2 in combinations(lauths, 2):
             edges_dict[a1.key, a2.key].append(p)
     # connected = {k for kl in edges_dict for k in kl}
-
     for k, v in node_pubs.items():
         node_pubs[k] = sorted(v, key=lambda p: -p.year)
     for k, v in edges_dict.items():
         edges_dict[k] = sorted(v, key=lambda p: -p.year)
+    nodes = [
+        to_node(s, node_pubs)
+        for s in lab.authors.values()  # if s.key in connected
+    ]
+    edges = [to_edge(k, v, lab.authors) for k, v in edges_dict.items()]
+    # for node in nodes:
+    #     node['connected'] = node['id'] in connected
 
-    return generate_html(
-        nodes=[
-            to_node(s, node_pubs)
-            for s in lab.authors.values()  # if s.key in connected
-        ],
-        edges=[to_edge(k, v, lab.authors) for k, v in edges_dict.items()],
-    )
+    return nodes, edges

gismap/gisgraphs/groups.py

@@ -0,0 +1,70 @@
+from domonic import tags
+import distinctipy
+
+
+def auto_groups(lab, groups=None, rng=None, pastel_factor=0.3):
+    if groups is None:
+        groups = ego_groups
+    else:
+        for k, v in ego_groups.items():
+            if k not in groups:
+                groups[k] = v
+            else:
+                groups[k] = {**v, **groups[k]}
+    res = {
+        group: groups.get(group, {"hidden": False})
+        for i, group in enumerate(
+            {
+                a.metadata.group: None
+                for a in lab.authors.values()
+                if a and a.metadata.group
+            }
+        )
+    }
+    n_colors = len([None for g in res.values() if "color" not in g])
+    colors = distinctipy.get_colors(n_colors, pastel_factor=pastel_factor, rng=rng)
+    colors = [
+        f"rgb({int(r * 255)},{int(g * 255)},{int(b * 255)})" for r, g, b in colors
+    ]
+    i = 0
+    for group in res.values():
+        if "color" not in group:
+            group["color"] = colors[i]
+            i += 1
+    return res
+
+
+ego_groups = {
+    "star": {"display": "Star", "color": "rgb(210, 190, 70)", "hidden": False},
+    "planet": {"display": "Planets", "color": "rgb(80, 120, 200)", "hidden": False},
+    "moon": {"display": "Moons", "color": "rgb(140, 140, 140)", "hidden": False},
+}
+
+
+def make_legend(groups, uid):
+    legend = tags.div(_id=f"legend-{uid}", _class="legend")
+    if len(groups) > 1:
+        for group_name, props in groups.items():
+            color = props.get("color", "#cccccc")
+            display_name = props.get("display", group_name)
+            entry = tags.label(display_name, _class="legend-entry")
+            entry.appendChild(
+                tags.input(
+                    **{
+                        "type": "checkbox",
+                        "class": "legend-checkbox",
+                        "data-group": group_name,
+                    },
+                    checked=True,
+                )
+            )
+            entry.appendChild(
+                tags.span(
+                    _style=f"background-color: {color}; width: 14px; height: 14px; display: inline-block; margin-right: 5px; vertical-align: middle;"
+                )
+            )
+            legend.appendChild(entry)
+    entry = tags.label("Show Comets", _class="comet-entry")
+    entry.appendChild(tags.input(**{"type": "checkbox", "id": f"comet-{uid}"}))
+    legend.appendChild(entry)
+    return legend

gismap/gisgraphs/js.py

@@ -0,0 +1,190 @@
+from string import Template
+
+
+# language=javascript
+draw_script = """
+import { DataSet, Network } from $vis_url;
+
+const nodes = new DataSet($nodes);
+const edges = new DataSet($edges);
+const options = $options;
+const container = document.getElementById('vis-$uid');
+let hoveredEdgeId = null;
+let hoveredNodeId = null;
+
+// Get the group color and position of a node. Useful for gradient edges
+function getNodeInfos(network, node) {
+    if (node && !options.groups?.[node.group]?.hidden) {
+        return [options.groups[node.group]?.color, network.getPositions([node.id])[node.id]]
+    }
+    return [false, false];
+}
+
+
+// main course
+function draw_graph() {
+    // No clean redraw so far, so we re-create everything :(
+    // Set hidden groups according to legend, if any
+    document.querySelectorAll('#legend-$uid .legend-checkbox').forEach(cb => {
+    const group = cb.getAttribute('data-group');
+    options.groups[group].hidden = !cb.checked;
+        });
+
+
+    // First compute the nodes to display.
+    var visibleNodes = new DataSet(nodes.get({
+      filter: node => !options.groups?.[node.group]?.hidden}));
+    var visibleNodeIds = new Set(visibleNodes.map(node => node.id));
+    // Reduce edges
+    const visibleEdges = new DataSet(edges.get({
+        filter: edge => visibleNodeIds.has(edge.from) && visibleNodeIds.has(edge.to)}));
+    //  Optiional: remove comets
+    if (!document.getElementById("comet-$uid")?.checked) {
+        visibleNodeIds = new Set();
+        visibleEdges.forEach(edge => {
+            visibleNodeIds.add(edge.from);
+            visibleNodeIds.add(edge.to);
+        });
+        visibleNodes = new DataSet(nodes.get({filter: node => visibleNodeIds.has(node.id)}));
+    }
+
+
+    // Set graph, nodes, and edges
+    const network = new Network(container, {nodes: visibleNodes, edges: visibleEdges}, options);
+    network.once("afterDrawing", function () {
+      network.fit({ maxZoomLevel: 3 });
+    });
+    const netNodes = network.body.data.nodes;
+    const netEdges = network.body.data.edges;
+
+    // Gradient edges
+    network.on("beforeDrawing", function(ctx) {
+        const selectedEdgeIds = network.getSelectedEdges();
+        netEdges.forEach(edge => {
+            const [fromColor, fromPos] = getNodeInfos(network, netNodes.get(edge.from))
+            const [toColor, toPos] = getNodeInfos(network, netNodes.get(edge.to))
+
+        if (fromColor && toColor && (fromColor !== toColor) && fromPos && toPos ) {
+            let width = edge.width || 2;
+            if (selectedEdgeIds.includes(edge.id) || hoveredEdgeId === edge.id || hoveredNodeId === edge.from || hoveredNodeId === edge.to) width *= 1.8;
+
+            // Gradient
+            const grad = ctx.createLinearGradient(fromPos.x, fromPos.y, toPos.x, toPos.y);
+            grad.addColorStop(0, fromColor);
+            grad.addColorStop(1, toColor);
+
+            // Draw line
+            ctx.save();
+            ctx.strokeStyle = grad;
+            ctx.lineWidth = width;
+            ctx.beginPath();
+            ctx.moveTo(fromPos.x, fromPos.y);
+            ctx.lineTo(toPos.x, toPos.y);
+            ctx.stroke();
+            ctx.restore();
+        }
+    });
+});
+
+    // Hover tooltip & record
+    network.on("hoverEdge", params => {
+        const edge = netEdges.get(params.edge);
+        network.body.container.title = edge.hover || '';
+        hoveredEdgeId = params.edge;
+    });
+
+    network.on("blurEdge", params => {
+        network.body.container.title = '';
+        hoveredEdgeId = null;
+    });
+
+    network.on("hoverNode", params => {
+        const node = netNodes.get(params.node);
+        netNodes.update({id: node.id, borderWidth: 10})
+        network.body.container.title = node.hover || '';
+        hoveredNodeId = params.node;
+    });
+    network.on("blurNode", params => {
+        const node = netNodes.get(params.node);
+        netNodes.update({id: node.id, borderWidth: 5})
+        network.body.container.title = '';
+        hoveredNodeId = null;
+    });
+
+
+    // Modal overlay
+    const modal = document.getElementById('modal-$uid');
+    const modalBody = document.getElementById('modal-body-$uid');
+    const modalClose = document.getElementById('modal-close-$uid');
+    network.on("click", function(params) {
+      if (params.nodes.length === 1) {
+        const node = netNodes.get(params.nodes[0]);
+        modalBody.innerHTML = node.overlay || '';
+        modal.style.display = "block";
+      } else if (params.edges.length === 1) {
+        const edge = netEdges.get(params.edges[0]);
+        modalBody.innerHTML = edge.overlay || '';
+        modal.style.display = "block";
+      } else {
+        modal.style.display = "none";
+      }
+    });
+    modalClose.onclick = function() { modal.style.display = "none"; };
+    window.onclick = function(event) {
+      if (event.target == modal) { modal.style.display = "none"; }
+    };
+}
+
+draw_graph();
+
+"""
+
+# language=javascript
+redraw_script = """
+document.getElementById('redraw-$uid').addEventListener('click', function(event) {
+    event.preventDefault();  // Prevent page jump
+    draw_graph();
+});
+
+"""
+
+# language=javascript
+fs_script = """
+document.getElementById('fullscreen-$uid').addEventListener('click', function(event) {
+    event.preventDefault();
+    let elem = document.getElementById('box-$uid');
+    if (!document.fullscreenElement) {
+        // Request fullscreen mode
+        if (elem.requestFullscreen) {
+            elem.requestFullscreen();
+        } else if (elem.webkitRequestFullscreen) { /* Safari */
+            elem.webkitRequestFullscreen();
+        } else if (elem.msRequestFullscreen) { /* IE11 */
+            elem.msRequestFullscreen();
+        }
+    } else {
+        // Exit fullscreen mode
+        if (document.exitFullscreen) {
+            document.exitFullscreen();
+        } else if (document.webkitExitFullscreen) { /* Safari */
+            document.webkitExitFullscreen();
+        } else if (document.msExitFullscreen) { /* IE11 */
+            document.msExitFullscreen();
+        }
+    }
+});
+
+"""
+
+# language=javascript
+legend_script = """
+// Refresh when boxes are changed
+document.querySelectorAll("#legend-$uid input").forEach(cb => {
+  cb.addEventListener('change', draw_graph);
+});
+
+
+"""
+
+
+default_script = Template(draw_script + redraw_script + fs_script + legend_script)

gismap/gisgraphs/options.py

@@ -0,0 +1,37 @@
+physics = {
+    "solver": "forceAtlas2Based",
+    "forceAtlas2Based": {
+        "gravitationalConstant": -50,
+        "centralGravity": 0.01,
+        "springLength": 200,
+        "springConstant": 0.08,
+        "damping": 0.98,
+        "avoidOverlap": 1,
+    },
+    "maxVelocity": 10,
+    "minVelocity": 0.9,
+    "stabilization": {
+        "enabled": True,
+        "iterations": 500,
+        "updateInterval": 50,
+        "onlyDynamicEdges": False,
+        "fit": True,
+    },
+    "timestep": 0.25,
+}
+
+nodes = {
+    "shape": "circle",
+    "size": 20,
+    "font": {"size": 16, "color": "#111"},
+    "color": "rgb(59, 101, 178)",
+    "borderWidth": 5,
+}
+
+edges = {
+    "width": 2,
+    # 'color': {'color': '#888', 'highlight': '#f5a25d'},
+    "smooth": False,  # {"type": 'continuous'}
+}
+
+interaction = {"hover": True}