gismap 0.1.0__py3-none-any.whl

gismap/lab/lab.py

@@ -0,0 +1,152 @@
+from gismo import MixInIO
+from dataclasses import dataclass, field
+
+from gismap.utils.common import LazyRepr
+from gismap.utils.logger import logger
+from gismap.sources.multi import SourcedAuthor
+from gismap.sources.multi import regroup_authors, regroup_publications
+from gismap.sources.hal import HAL
+from gismap.sources.dblp import DBLP
+
+
+@dataclass(repr=False)
+class AuthorMetadata(LazyRepr):
+    """
+    Optional information about an author to be used to enhance her presentation.
+
+    Attributes
+    ----------
+
+    url: :class:`str`
+        Homepage of the author.
+    img: :class:`str`
+        Url to a picture.
+    group: :class:`str`
+        Group of the author.
+    position: :class:`tuple`
+        Coordinates of the author.
+    """
+
+    url: str = None
+    img: str = None
+    group: str = None
+    position: tuple = None
+
+
+@dataclass(repr=False)
+class LabAuthor(SourcedAuthor):
+    metadata: AuthorMetadata = field(default_factory=AuthorMetadata)
+
+    def auto_sources(self, dbs=None):
+        """
+        Automatically populate the sources based on author's name.
+
+        Parameters
+        ----------
+        dbs: :class:`list`, default=[:class:`~gismap.sources.hal.HAL`, :class:`~gismap.sources.dblp.DBLP`]
+            List of DB sources to use.
+
+        Returns
+        -------
+        None
+        """
+        if dbs is None:
+            dbs = [HAL, DBLP]
+        sources = []
+        for db in dbs:
+            source = db.search_author(self.name)
+            if len(source) == 0:
+                logger.warning(f"{self.name} not found in {db.db_name}")
+            elif len(source) > 1:
+                logger.warning(f"Multiple entries for {self.name} in {db.db_name}")
+            sources += source
+        if len(sources) > 0:
+            self.sources = sources
+
+
+class Lab(MixInIO):
+    """
+    Abstract class for labs.
+
+    Labs can be saved with the `dump` method and loaded with the `load` method.
+
+    Parameters
+    ----------
+    name: :class:`str`
+        Name of the lab. Can be set as class or instance attribute.
+    dbs: :class:`list`, default=[:class:`~gismap.sources.hal.HAL`, :class:`~gismap.sources.dblp.DBLP`]
+        List of DB sources to use.
+    """
+
+    name = None
+    dbs = [HAL, DBLP]
+
+    def __init__(self, name=None, dbs=None):
+        if name is not None:
+            self.name = name
+        if dbs is not None:
+            self.dbs = dbs
+        self.authors = None
+        self.publications = None
+
+    def __repr__(self):
+        return f"Lab {self.name}"
+
+    def _author_iterator(self):
+        """
+        Yields
+        ------
+        :class:`~gismap.lab.lab.LabAuthor`
+        """
+        raise NotImplementedError
+
+    def update_authors(self):
+        """
+        Populate the authors attribute (:class:`dict` [:class:`str`, :class:`~gismap.lab.lab.LabAuthor`]).
+
+        Returns
+        -------
+        None
+        """
+        self.authors = dict()
+        for author in self._author_iterator():
+            author.auto_sources(dbs=self.dbs)
+            if author.sources:
+                self.authors[author.key] = author
+
+    def update_publis(self):
+        """
+        Populate the publications attribute (:class:`dict` [:class:`str`, :class:`~gismap.sources.multi.SourcedPublication`]).
+
+        Returns
+        -------
+        None
+        """
+        pubs = dict()
+        for author in self.authors.values():
+            pubs.update(author.get_publications(clean=False))
+        regroup_authors(self.authors, pubs)
+        self.publications = regroup_publications(pubs)
+
+
+class ListLab(Lab):
+    """
+    Simplest way to create a lab: with a list of names.
+
+    Parameters
+    ----------
+    author_list: :class:`list` of :class:`str`
+        List of authors names.
+    args: :class:`list`
+        Arguments to pass to the :class:`~gismap.lab.lab.Lab` constuctor.
+    kwargs: :class:`dict`
+        Keyword arguments to pass to the :class:`~gismap.lab.lab.Lab` constuctor.
+    """
+
+    def __init__(self, author_list, *args, **kwargs):
+        self.author_list = author_list
+        super().__init__(*args, **kwargs)
+
+    def _author_iterator(self):
+        for name in self.author_list:
+            yield LabAuthor(name=name, metadata=AuthorMetadata())

gismap/lab/lip6.py

@@ -0,0 +1,43 @@
+from bs4 import BeautifulSoup as Soup
+import re
+
+from gismap.lab.lab import Lab, AuthorMetadata, LabAuthor
+from gismap.utils.requests import get
+
+
+class Lip6Lab(Lab):
+    """
+    Class for handling a LIP6 team using `https://www.lip6.fr/recherche/team_membres.php?acronyme=*team_acronym*` as entry point.
+    Default to `NPA` team.
+    """
+
+    name = "NPA"
+
+    def _author_iterator(self):
+        url = f"https://www.lip6.fr/recherche/team_membres.php?acronyme={self.name}"
+        soup = Soup(get(url), "lxml")
+        for a in soup.table("a"):
+            name = a.text.replace("\xa0", " ").strip()
+            if not name:
+                continue
+            metadata = AuthorMetadata(group=self.name)
+            previous = a.find_previous_sibling()
+            if previous is not None and "user" in previous.get("class", []):
+                metadata.url = previous["href"].strip()
+            yield LabAuthor(name=name, metadata=metadata)
+
+
+class Lip6(Lip6Lab):
+    """
+    Class for handling all LIP6 teams using `https://www.lip6.fr/informations/annuaire.php` to get team names.
+    """
+
+    name = "LIP6"
+
+    def _author_iterator(self):
+        groups = re.compile(r'acronyme=(.*?)[\'"]')
+        for group in groups.findall(
+            get("https://www.lip6.fr/informations/annuaire.php")
+        ):
+            for author in Lip6Lab(name=group)._author_iterator():
+                yield author

gismap/lab/toulouse.py

@@ -0,0 +1,47 @@
+import re
+from bs4 import BeautifulSoup as Soup
+from gismap.lab.lab import Lab, AuthorMetadata, LabAuthor
+from gismap.utils.requests import get
+
+
+def name_changer(name, rosetta):
+    return rosetta.get(name, name)
+
+
+class LaasLab(Lab):
+    """
+    Class for handling a LAAS team from its name.
+    Default to `sara` team.
+    """
+
+    name = "sara"
+    base_url = "https://www.laas.fr"
+    rosetta = {"Urtzi Ayesta Morate": "Urtzi Ayesta"}
+
+    def _author_iterator(self):
+        soup = Soup(get(f"{self.base_url}/fr/equipes/{self.name}/"), features="lxml")
+        for a in soup("div", {"class": "membre"})[0]("a"):
+            url = self.base_url + a["href"]
+            name = name_changer(a.img["alt"], self.rosetta)
+            img = (
+                self.base_url + a.img["src"]
+                if "public_avatar" in a.img["class"]
+                else None
+            )
+            yield LabAuthor(name=name, metadata=AuthorMetadata(url=url, img=img))
+
+
+class Solace(Lab):
+    """
+    Class for handling the Solace team (`https://solace.cnrs.fr`).
+    """
+
+    name = "Solace"
+    regex = re.compile(r"<li>(.*?)(,| \(|</li>)")
+
+    def _author_iterator(self):
+        html = get("https://solace.cnrs.fr/people.html")
+        for name, _ in self.regex.findall(html):
+            soup = Soup(name, features="lxml")
+            url = soup.a["href"] if soup.a else None
+            yield LabAuthor(name=soup.text.strip(), metadata=AuthorMetadata(url=url))

gismap/lab/vis.py

@@ -0,0 +1,171 @@
+from string import Template
+import uuid
+import json
+
+
+vis_template = Template("""
+<div id="${container_id}"></div>
+<div id="${modal_id}" class="modal">
+  <div class="modal-content">
+    <span class="close" id="${modal_close_id}">&times;</span>
+    <div id="${modal_body_id}"></div>
+  </div>
+</div>
+<style>
+  /* Styles adaptatifs pour dark/light */
+  #${container_id} {
+    width: 1200px; height: 800px; border: 1px solid #444;
+    background: #181818;
+  }
+  .modal {
+    display: none; position: fixed; z-index: 1000; left: 0; top: 0; width: 100%; height: 100%;
+    overflow: auto; background-color: rgba(10,10,10,0.85);
+  }
+  .modal-content {
+    background-color: #23272e; color: #f0f0f0;
+    margin: 10% auto; padding: 24px; border: 1px solid #888;
+    width: 50%; border-radius: 8px;
+    box-shadow: 0 5px 15px rgba(0,0,0,.6);
+  }
+  .close {
+    color: #aaa; float: right; font-size: 28px; font-weight: bold; cursor: pointer;
+  }
+  .close:hover, .close:focus { color: #fff; text-decoration: none; cursor: pointer; }
+  @media (prefers-color-scheme: light) {
+    #${container_id} { background: #fff; border: 1px solid #ccc; }
+    .modal { background-color: rgba(220,220,220,0.85); }
+    .modal-content { background: #fff; color: #222; border: 1px solid #888; }
+    .close { color: #222; }
+    .close:hover, .close:focus { color: #555; }
+  }
+</style>
+<script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+<script type="text/javascript">
+(function() {
+  // Détection du thème
+  function getTheme() {
+    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+  }
+  function getVisOptions(theme) {
+    if (theme === 'dark') {
+      return {
+        nodes: {
+          shape: 'circle', size: 20,
+          font: { size: 16, color: '#f0f0f0' },
+          color: {
+            background: '#222e3c',
+            border: '#5d90f5',
+            highlight: { background: '#2f3d4d', border: '#f5a25d' }
+          },
+          borderWidth: 2
+        },
+        edges: {
+          width: 2,
+          color: { color: '#888', highlight: '#f5a25d' },
+          smooth: { type: 'continuous' }
+        },
+        interaction: { hover: true }
+      };
+    } else {
+      return {
+        nodes: {
+          shape: 'circle', size: 20,
+          font: { size: 16, color: '#222' },
+          color: {
+            background: '#e3eaff',
+            border: '#3d6cf7',
+            highlight: { background: '#fffbe6', border: '#f5a25d' }
+          },
+          borderWidth: 2
+        },
+        edges: {
+          width: 2,
+          color: { color: '#848484', highlight: '#f5a25d' },
+          smooth: { type: 'continuous' }
+        },
+        interaction: { hover: true }
+      };
+    }
+  }
+  const nodes = new vis.DataSet(${nodes_json});
+  const edges = new vis.DataSet(${edges_json});
+  const container = document.getElementById('${container_id}');
+  let network = null;
+  function renderNetwork() {
+    const theme = getTheme();
+    const options = getVisOptions(theme);
+    network = new vis.Network(container, { nodes: nodes, edges: edges }, options);
+    // Tooltip survol
+    network.on("hoverNode", function(params) {
+      const node = nodes.get(params.node);
+      network.body.container.title = node.hover || '';
+    });
+    network.on("blurNode", function(params) {
+      network.body.container.title = '';
+    });
+    network.on("hoverEdge", function(params) {
+      const edge = edges.get(params.edge);
+      network.body.container.title = edge.hover || '';
+    });
+    network.on("blurEdge", function(params) {
+      network.body.container.title = '';
+    });
+    // Modal overlay
+    const modal = document.getElementById('${modal_id}');
+    const modalBody = document.getElementById('${modal_body_id}');
+    const modalClose = document.getElementById('${modal_close_id}');
+    network.on("click", function(params) {
+      if (params.nodes.length === 1) {
+        const node = nodes.get(params.nodes[0]);
+        modalBody.innerHTML = node.overlay || '';
+        modal.style.display = "block";
+      } else if (params.edges.length === 1) {
+        const edge = edges.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"; }
+    };
+  }
+  renderNetwork();
+  // Adapter dynamiquement si le thème change
+  window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function() {
+    renderNetwork();
+  });
+})();
+</script>
+""")
+
+
+def generate_html(nodes, edges):
+    """
+    Parameters
+    ----------
+    nodes: :class:`list`
+    edges: :class:`list`
+
+    Returns
+    -------
+    :class:`str`
+    """
+    uid = str(uuid.uuid4())[:8]  # identifiant unique pour éviter les collisions
+    container_id = f"mynetwork_{uid}"
+    modal_id = f"modal_{uid}"
+    modal_body_id = f"modal_body_{uid}"
+    modal_close_id = f"modal_close_{uid}"
+    nodes_json = json.dumps(nodes)
+    edges_json = json.dumps(edges)
+    dico = {
+        "container_id": container_id,
+        "modal_id": modal_id,
+        "modal_body_id": modal_body_id,
+        "modal_close_id": modal_close_id,
+        "nodes_json": nodes_json,
+        "edges_json": edges_json,
+    }
+    return vis_template.substitute(dico)  # html_template

gismap/search.py

@@ -0,0 +1,215 @@
+from collections import defaultdict
+from string import Template
+
+from gismap.utils.text import reduce_keywords, Corrector
+
+
+class SearchAction:
+    """
+    Blueprint for extracting search results out of a gismo.
+    """
+
+    def __init__(self, name=None, post=None):
+        self.name = name
+        self.post = (lambda x: x) if post is None else post
+
+    def process(self, gismo):
+        raise NotImplementedError
+
+    def run(self, gismo):
+        return self.post(self.process(gismo))
+
+
+def p2t(publis):
+    """
+    Parameters
+    ----------
+    publis: :class:`list`
+        List of publications
+
+    Returns
+    -------
+    :class:`str`
+        Publications converted in text and concatenated.
+    """
+    return "\n".join(a.string for a in publis)
+
+
+def l2t(lis):
+    """
+
+    Parameters
+    ----------
+    lis: :class:`list`
+        List of text.
+    Returns
+    -------
+    :class:`str`
+        Concatenation, comma-separated.
+    """
+    return ", ".join(lis)
+
+
+class SearchDocuments(SearchAction):
+    """Gives *k* best covering articles."""
+
+    def __init__(self, name="articles", post=None, k=5):
+        if post is None:
+            post = p2t
+        super().__init__(name=name, post=post)
+        self.k = k
+
+    def process(self, gismo):
+        return gismo.get_documents_by_coverage(k=self.k)
+
+
+class SearchFeatures(SearchAction):
+    """Gives best keywords."""
+
+    def __init__(self, name="keywords", post=None):
+        if post is None:
+            post = l2t
+        super().__init__(name=name, post=post)
+
+    def process(self, gismo):
+        return reduce_keywords(gismo.get_features_by_rank())
+
+
+class SearchLandmarks(SearchAction):
+    """Gives best landmarks."""
+
+    def __init__(self, name="landmarks", post=None, lmks=None):
+        if post is None:
+            post = l2t
+        super().__init__(name=name, post=post)
+        self.lmks = lmks
+
+    def process(self, gismo):
+        return self.lmks.get_landmarks_by_rank(gismo)
+
+
+class Search:
+    """
+    Builds a gismo search engine.
+
+    Parameters
+    ----------
+    gismo: :class:`~gismo.gismo.Gismo`
+        Gismo to use.
+    action_list: :class:`list`
+        List of actions to perform.
+    post: callable, optional
+        Output transformation.
+    corrector: :class:`Bool`, default=True
+        Implement word correction.
+    """
+
+    def __init__(self, gismo, action_list, post=None, corrector=True):
+        self.gismo = gismo
+        self.action_list = action_list
+        self.post = (lambda x: x) if post is None else post
+        if corrector:
+            self.corrector = Corrector(gismo.embedding.features)
+        else:
+            self.corrector = None
+
+    def __call__(self, query):
+        if self.corrector is not None:
+            query = self.corrector(query)
+        success = self.gismo.rank(query)
+        res = dict()
+        if success:
+            for action in self.action_list:
+                res[action.name] = action.run(self.gismo)
+        return self.post({"query": query, "success": success, "results": res})
+
+
+def search_to_text(res):
+    """
+    Parameters
+    ----------
+    res: :class:`dict`
+        Raw results of search.
+
+    Returns
+    -------
+    :class:`str`
+        Text representation of the results.
+    """
+    query = res["query"]
+    if not res["success"]:
+        return f"Failure: ``{query}'' not found!"
+    output = f"Results for ``{query}'':\n"
+    for k, v in res["results"].items():
+        output += f"Suggested {k}: {v}\n"
+    return output
+
+
+publi_template = Template("""
+<li>
+<i>$title</i>, by $authors. $venue, $year. $hal $dblp
+</li>
+""")
+
+
+def publi_to_html(publi):
+    dico = dict()
+    for db in ["hal", "dblp"]:
+        source = publi.sources.get(db)
+        if source:
+            dico[db] = f"<a href='{source['url']}' target='_blank'>{db.upper()}</a>"
+        else:
+            dico[db] = ""
+    dico["authors"] = ", ".join(a.name for a in publi.authors)
+    for key in ["title", "venue", "year"]:
+        dico[key] = getattr(publi, key)
+    return publi_template.substitute(dico)
+
+
+def publis_to_html(publis):
+    rows = "\n".join(publi_to_html(p) for p in publis)
+    return f"<ul>\n{rows}\n</ul>"
+
+
+html_template = Template("""
+<div>
+<h4>Search: <i>$query</i></h4>
+<div>
+<h5>Associated keywords:</h5>
+<div>$keywords</div>
+</div>
+<div>
+<h5>Associated Projects:</h5>
+<div>$projects</div>
+</div>
+<div>
+<h5>Suggested people:</h5>
+<div>$members</div>
+</div>
+<div>
+<h5>Suggested publications:</h5>
+<div>$publis</div>
+</div>
+</div>
+
+""")
+
+
+def search_to_html(res):
+    """
+    Parameters
+    ----------
+    res: :class:`dict`
+        Raw results of search.
+
+    Returns
+    -------
+    :class:`str`
+        HTML representation of the results.
+    """
+    dico = defaultdict(str)
+    dico.update(res["results"])
+    dico["query"] = res["query"]
+    if res["success"]:
+        dico["publis"] = publis_to_html(dico["articles"])
+    return html_template.safe_substitute(dico)