gismap 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

gismap/__init__.py

@@ -2,6 +2,8 @@
 
 from importlib.metadata import metadata
 
+from gismap.sources.hal import HAL as HAL, HALAuthor as HALAuthor
+from gismap.sources.dblp import DBLP as DBLP, DBLPAuthor as DBLPAuthor
 from gismap.utils.common import get_classes as get_classes
 from gismap.gismo import make_gismo as make_gismo
 from gismap.search import (

gismap/lab/__init__.py

@@ -1,10 +1,10 @@
 from gismap.lab.lab import (
     Lab as Lab,
     ListLab as ListLab,
-    LabAuthor as LabAuthor,
-    AuthorMetadata as AuthorMetadata,
 )
 from gismap.lab.lip6 import Lip6 as Lip6, Lip6Lab as Lip6Lab
 from gismap.lab.toulouse import Solace as Solace, LaasLab as LaasLab
 from gismap.lab.graph import lab2graph as lab2graph
 from gismap.lab.vis import generate_html as generate_html
+from gismap.lab.egomap import EgoMap as EgoMap
+from gismap.lab.lab_author import LabAuthor as LabAuthor

gismap/lab/egomap.py

@@ -0,0 +1,42 @@
+from gismap.lab.lab import Lab
+from gismap.lab.lab_author import LabAuthor
+
+
+class EgoMap(Lab):
+    """
+    Parameters
+    ----------
+    sun
+    args
+    kwargs
+
+    Examples
+    --------
+
+    >>> dang = EgoMap("The-Dang Huynh", dbs="hal")
+    >>> dang.build(target=10)
+    >>> sorted(a.name for a in dang.authors.values())  # doctest: +NORMALIZE_WHITESPACE
+    ['Bruno Kauffmann', 'Chung Shue Chen', 'Fabien Mathieu', 'François Baccelli', 'Laurent Viennot', 'Ludovic Noirie',
+    'Siu-Wai Ho', 'Sébastien Tixeuil', 'The-Dang Huynh', 'Yannick Carlinet']
+    """
+
+    def __init__(self, sun, *args, **kwargs):
+        if isinstance(sun, str):
+            sun = LabAuthor(sun)
+        sun.metadata.position = (0, 0)
+        self.sun = sun
+        super().__init__(*args, **kwargs)
+
+    def _author_iterator(self):
+        yield self.sun
+
+    def build(self, **kwargs):
+        target = kwargs.pop("target", 50)
+        group = kwargs.pop("group", "moon")
+        self.update_authors(desc="Sun metadata")
+        self.update_publis(desc="Sun publications")
+        kwargs["target"] = target - len(self.authors)
+        self.expand(group=None, desc="Planets", **kwargs)
+        kwargs.update({"target": target - len(self.authors), "group": group})
+        if kwargs["target"] > 0:
+            self.expand(desc="Moons", **kwargs)

gismap/lab/expansion.py

@@ -0,0 +1,240 @@
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from bof.fuzz import Process
+import numpy as np
+
+from gismap.utils.text import normalized_name
+from gismap.sources.multi import sort_author_sources
+from gismap.lab.lab_author import LabAuthor
+
+
+@dataclass
+class ProspectStrength:
+    """
+    Measures the interaction between an external author and a lab by counting co-authors and publications.
+
+    A (max,+) addition is handled to deal with multiple keys.
+
+    Examples
+    --------
+
+    >>> a1 = ProspectStrength(3, 5)
+    >>> a2 = ProspectStrength(2, 10)
+    >>> a1 > a2
+    True
+    >>> a1 + a2
+    ProspectStrength(coauthors=3, publications=15)
+    """
+
+    coauthors: int
+    publications: int
+
+    def __call__(self):
+        return self.coauthors, self.publications
+
+    def __add__(self, other):
+        if other == 0:
+            return self
+        return ProspectStrength(
+            coauthors=max(self.coauthors, other.coauthors),
+            publications=self.publications + other.publications,
+        )
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __lt__(self, other):
+        return self() < other()
+
+
+def count_prospect_entries(lab):
+    """
+    Associate to external coauthors (prospects) their lab strength.
+
+    Parameters
+    ----------
+    lab: :class:`~gismap.lab.lab.Lab`
+        Reference lab.
+
+    Returns
+    -------
+    :class:`dict` of :class:`str` to :class:`~gismap.lab.expansion.ProspectStrength`
+        Lab strengths.
+    """
+    count_coauthors = defaultdict(set)
+    count_publications = []
+    for p in lab.publications.values():
+        for s in p.sources:
+            new_authors = set()
+            lab_authors = set()
+            for a in s.authors:
+                if hasattr(a, "db_name"):
+                    new_authors.add(a.key)
+                    count_publications.append(a.key)
+                else:
+                    lab_authors.add(a.key)
+            for l in lab_authors:
+                count_coauthors[l].update(new_authors)
+
+    count_coauthors = Counter(
+        k for new_authors in count_coauthors.values() for k in new_authors
+    )
+    count_publications = Counter(count_publications)
+
+    return {
+        k: ProspectStrength(
+            coauthors=count_coauthors.get(k, 0), publications=count_publications[k]
+        )
+        for k in count_publications
+    }
+
+
+class Prospect:
+    """
+    Candidate for integration to lab.
+
+    Parameters
+    ----------
+    author: :class:`~gismap.sources.models.Author`
+        Reference author. Must have a key.
+    strengths: :class:`dict`
+        Dictionary of ProspectStrength.
+    """
+
+    def __init__(self, author, strengths):
+        self.name = normalized_name(author.name)
+        self.author = author
+        self.score = strengths[author.key]
+
+    def __lt__(self, other):
+        return self.score < other.score
+
+    def __repr__(self):
+        return f"Prospect({self.name}, key={self.author.key}, s={self.score()}"
+
+
+def get_prospects(lab):
+    """
+    Parameters
+    ----------
+    lab: :class:`~gismap.lab.lab.Lab`
+        Reference lab.
+
+    Returns
+    -------
+    :class:`list` of :class:`~gismap.lab.expansion.Prospect`
+        List of prospects.
+    """
+    strengths = count_prospect_entries(lab)
+    prospect_dico = {
+        a.key: a
+        for p in lab.publications.values()
+        for s in p.sources
+        for a in s.authors
+        if hasattr(a, "db_name") and all(f(a) for f in lab.author_selectors)
+    }
+    return [Prospect(a, strengths) for a in prospect_dico.values()]
+
+
+@dataclass
+class Member:
+    """
+    Basic information
+    """
+
+    name: str
+    key: str
+
+
+def get_member_names(lab):
+    """
+    Parameters
+    ----------
+    lab: :class:`~gismap.lab.lab.Lab`
+        Reference lab.
+
+    Returns
+    -------
+    :class:`list`
+        Tuples simplified-name -> key
+    """
+    return [
+        (name, k)
+        for k, a in lab.authors.items()
+        for name in {normalized_name(n) for n in [a.name, *a.aliases]}
+    ]
+
+
+def trim_sources(author):
+    """
+    Inplace reduction of sources, keeping one unique source per db.
+
+    Parameters
+    ----------
+    author: :class:`~gismap.sources.multi.SourcedAuthor`
+        An author.
+
+    Returns
+    -------
+    None
+    """
+    sources = []
+    seen = set()
+    for s in author.sources:
+        if s.db_name not in seen:
+            seen.add(s.db_name)
+            sources.append(s)
+    author.sources = sources
+
+
+def proper_prospects(
+    lab, length_impact=0.05, threshold=80, n_range=4, max_new=None, trim=True
+):
+    member_names = get_member_names(lab)
+    prospects = get_prospects(lab)
+
+    if len(member_names) == 0 or len(prospects) == 0:
+        return dict(), dict()
+
+    done = np.zeros(len(prospects), dtype=bool)
+
+    # Compare current and prospects names to re-attach ghosts
+    p = Process(length_impact=length_impact, n_range=n_range)
+    p.allow_updates = False
+    p.fit([n[0] for n in member_names])
+    jc = p.transform([prospect.name for prospect in prospects])
+    best_choice = np.argmax(jc, axis=1)
+    existing = dict()
+    for i, j in enumerate(best_choice):
+        if jc[i, j] > threshold:
+            existing[prospects[i].author.key] = member_names[j][1]
+            done[i] = True
+
+    # Regroup remaining prospects
+    p.reset()
+    names = [prospect.name for prospect in prospects]
+    p.fit(names)
+    jc = p.transform(names)
+    new_lab = []
+    for i, prospect in enumerate(prospects):
+        if done[i]:
+            continue
+        locs = [j for j in np.where(jc[i, :] > threshold)[0] if not done[j]]
+        done[locs] = True
+        sources = sort_author_sources([prospects[j].author for j in locs])
+        strength = sum(prospects[j].score for j in locs)
+        new_author = LabAuthor.from_sources(sources)
+        new_lab.append((strength, new_author))
+
+    # Extract top prospects
+    new_lab = [l[1] for l in sorted(new_lab, key=lambda l: l[0], reverse=True)][
+        :max_new
+    ]
+    new_rosetta = {s.key: a for a in new_lab for s in a.sources}
+
+    # Remove extra sources
+    if trim:
+        for a in new_lab:
+            trim_sources(a)
+
+    return existing, new_rosetta

gismap/lab/filters.py

@@ -0,0 +1,18 @@
+def taboos(txt, words):
+    if isinstance(words, str):
+        return words not in txt
+    else:
+        return all(w not in txt for w in words)
+
+def publication_size_filter(n_max=10):
+    return lambda p: len(p.authors) < n_max
+
+def publication_taboo_filter(w=None):
+    if w is None:
+        w = ["Editorial", "Foreword"]
+    return lambda p: taboos(p.title, w)
+
+def author_taboo_filter(w=None):
+    if w is None:
+        w = ["Buob", "Kofman"]
+    return lambda a: taboos(a.name, w)

gismap/lab/graph.py

@@ -59,8 +59,11 @@ def publication_to_html(pub):
     HTML string with hyperlinks where applicable.
     """
     # Title as link if available
-    if getattr(pub, "url", None):
-        title_html = f'<a href="{pub.url}" target="_blank">{pub.title}</a>'
+    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
 
@@ -129,7 +132,7 @@ def to_node(s, node_pubs):
     """
     Parameters
     ----------
-    s: :class:`~gismap.lab.lab.LabAuthor`
+    s: :class:`~gismap.lab.lab_author.LabAuthor`
         Searcher.
     node_pubs: :class:`dict`
         Lab publications.
@@ -203,17 +206,17 @@ def lab2graph(lab):
     >>> lab.update_publis()
     >>> len(lab.authors)
     2
-    >>> len(lab.publications)
-    453
+    >>> 400 < len(lab.publications) < 440
+    True
     >>> html = lab2graph(lab)
     >>> html[:80]  # doctest: +ELLIPSIS
-    '\\n<div id="mynetwork_..."></div>\\n<div id="modal_..." class="modal">\\n  <'
+    '\\n<div class="gismap-content">\\n<div id="mynetwork_..."></div>\\n<a\\n  href="htt'
     """
     node_pubs = {k: [] for k in lab.authors}
     edges_dict = defaultdict(list)
     for p in lab.publications.values():
-        # Some authors are twice in the author list for some reason. This should take care of it.
-        lauths = {a.key: a for a in p.authors if a.__class__.__name__ == "LabAuthor"}
+        # Strange things can happen with multiple sources. This should take care of it.
+        lauths = {a.key: a for source in p.sources for a in source.authors if a.__class__.__name__ == "LabAuthor"}
         lauths = sorted([a for a in lauths.values()], key=lambda a: str(a.key))
         for a in lauths:
             node_pubs[a.key].append(p)

gismap/lab/lab.py

@@ -1,67 +1,24 @@
 from gismo import MixInIO
-from dataclasses import dataclass, field
+from tqdm.auto import tqdm
+from IPython.display import display, HTML
+from pathlib import Path
 
-from gismap.utils.common import LazyRepr
+from gismap.utils.common import list_of_objects
 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
+from gismap.lab.lab_author import (
+    db_dict,
+    default_dbs,
+    AuthorMetadata,
+    LabAuthor,
+    labify_publications,
+)
+from gismap.sources.multi import (
+    regroup_authors,
+    regroup_publications,
+)
+from gismap.lab.expansion import proper_prospects
+from gismap.lab.filters import author_taboo_filter, publication_taboo_filter, publication_size_filter
+from gismap.lab.graph import lab2graph
 
 
 class Lab(MixInIO):
@@ -76,16 +33,23 @@ class Lab(MixInIO):
         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.
+    author_selectors: :class:`list`
+        Author filter. Default: minimal filtering.
+    publication_selectors: :class:`list`
+        Publication filter. Default: less than 10 authors to remove black holes.
     """
 
     name = None
-    dbs = [HAL, DBLP]
+    dbs = default_dbs
 
-    def __init__(self, name=None, dbs=None):
+    def __init__(
+        self, name=None, dbs=None):
         if name is not None:
             self.name = name
         if dbs is not None:
-            self.dbs = dbs
+            self.dbs = list_of_objects(dbs, db_dict, default=default_dbs)
+        self.author_selectors = [author_taboo_filter()]
+        self.publication_selectors = [publication_size_filter(), publication_taboo_filter()]
         self.authors = None
         self.publications = None
 
@@ -100,7 +64,7 @@ class Lab(MixInIO):
         """
         raise NotImplementedError
 
-    def update_authors(self):
+    def update_authors(self, desc="Author information"):
         """
         Populate the authors attribute (:class:`dict` [:class:`str`, :class:`~gismap.lab.lab.LabAuthor`]).
 
@@ -109,12 +73,17 @@ class Lab(MixInIO):
         None
         """
         self.authors = dict()
-        for author in self._author_iterator():
-            author.auto_sources(dbs=self.dbs)
+        for author in tqdm(self._author_iterator(), desc=desc):
+            if not all(f(author) for f in self.author_selectors):
+                continue
+            if len(author.sources) == 0:
+                author.auto_sources(dbs=self.dbs)
             if author.sources:
                 self.authors[author.key] = author
+            if author.metadata.img is None:
+                author.auto_img()
 
-    def update_publis(self):
+    def update_publis(self, desc="Publications information"):
         """
         Populate the publications attribute (:class:`dict` [:class:`str`, :class:`~gismap.sources.multi.SourcedPublication`]).
 
@@ -123,11 +92,58 @@ class Lab(MixInIO):
         None
         """
         pubs = dict()
-        for author in self.authors.values():
-            pubs.update(author.get_publications(clean=False))
+        for author in tqdm(self.authors.values(), desc=desc):
+            pubs.update(
+                author.get_publications(clean=False, selector=self.publication_selectors)
+            )
         regroup_authors(self.authors, pubs)
         self.publications = regroup_publications(pubs)
 
+    def expand(self, target=None, group="moon", desc="Moon information", **kwargs):
+        if target is None:
+            target = len(self.authors) // 3
+        old, rosetta = proper_prospects(self, max_new=target, **kwargs)
+        new = {a.key: a for a in rosetta.values()}
+        for k, v in old.items():
+            rosetta[k] = self.authors[v]
+        logger.debug(f"{len(new)} new authors selected")
+        if len(new) == 0:
+            logger.warning("Expansion failed: no new author found.")
+            return None
+
+        self.authors.update(new)
+
+        pubs = dict()
+        for author in tqdm(new.values(), desc=desc):
+            author.auto_img()
+            author.metadata.group = group
+            pubs.update(
+                author.get_publications(clean=False, selector=self.publication_selectors)
+            )
+
+        for pub in self.publications.values():
+            for source in pub.sources:
+                pubs[source.key] = source
+
+        labify_publications(pubs.values(), rosetta)
+
+        self.publications = regroup_publications(pubs)
+
+        return None
+
+    def html(self, **kwargs):
+        return lab2graph(self, **kwargs)
+
+    def save_html(self, name=None, **kwargs):
+        if name is None:
+            name = self.name
+        name = Path(name).with_suffix(".html")
+        with open(name, "wt", encoding="utf8") as f:
+            f.write(self.html(**kwargs))
+
+    def show_html(self, **kwargs):
+        display(HTML(self.html(**kwargs)))
+
 
 class ListLab(Lab):
     """

gismap/lab/lab_author.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass, field
+
+from gismap import get_classes, HAL, DBLP
+from gismap.sources.models import DB
+from gismap.sources.multi import SourcedAuthor, sort_author_sources
+from gismap.utils.common import LazyRepr, list_of_objects
+from gismap.utils.logger import logger
+
+db_dict = get_classes(DB, key="db_name")
+default_dbs = [HAL, 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_img(self):
+        for source in self.sources:
+            img = getattr(source, "img", None)
+            if img is not None:
+                self.metadata.img = img
+                break
+
+    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
+        """
+        dbs = list_of_objects(dbs, db_dict, default=default_dbs)
+        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 = sort_author_sources(sources)
+
+
+def labify_author(author, rosetta):
+    if isinstance(author, LabAuthor):
+        return author
+    return rosetta.get(author.key, author)
+
+
+def labify_publications(pubs, rosetta):
+    for pub in pubs:
+        pub.authors = [labify_author(a, rosetta) for a in pub.authors]
+        for source in getattr(pub, "sources", []):
+            source.authors = [labify_author(a, rosetta) for a in pub.authors]

gismap/lab/lip6.py

@@ -1,7 +1,8 @@
 from bs4 import BeautifulSoup as Soup
 import re
 
-from gismap.lab.lab import Lab, AuthorMetadata, LabAuthor
+from gismap.lab.lab import Lab
+from gismap.lab.lab_author import AuthorMetadata, LabAuthor
 from gismap.utils.requests import get
 
 

gismap/lab/toulouse.py

@@ -1,6 +1,7 @@
 import re
 from bs4 import BeautifulSoup as Soup
-from gismap.lab.lab import Lab, AuthorMetadata, LabAuthor
+from gismap.lab.lab import Lab
+from gismap.lab.lab_author import AuthorMetadata, LabAuthor
 from gismap.utils.requests import get