logger-36 2024.1__py3-none-any.whl → 2025.4__py3-none-any.whl

logger_36/catalog/handler/file.py

@@ -0,0 +1,128 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import dataclasses as d
+import logging as lggg
+import textwrap as txt_
+import typing as h
+from pathlib import Path as path_t
+
+from logger_36.constant.message import LINE_INDENT
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import RuleAsText
+from logger_36.type.handler import handler_extension_t
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class file_handler_t(lggg.FileHandler):
+
+    extension: handler_extension_t = d.field(init=False)
+    MessageFromRecord: h.Callable[..., tuple[str, str | None]] = d.field(init=False)
+
+    name: d.InitVar[str | None] = None
+    level: d.InitVar[int] = lggg.NOTSET
+    should_store_memory_usage: d.InitVar[bool] = False
+    message_width: d.InitVar[int] = -1
+    formatter: d.InitVar[lggg.Formatter | None] = None
+
+    path: d.InitVar[path_t | None] = None
+    handler_args: d.InitVar[tuple[h.Any, ...] | None] = None
+    handler_kwargs: d.InitVar[dict[str, h.Any] | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        should_store_memory_usage: bool,
+        message_width: int,
+        formatter: lggg.Formatter | None,
+        path: path_t | None,
+        handler_args: tuple[h.Any, ...] | None,
+        handler_kwargs: dict[str, h.Any] | None,
+    ) -> None:
+        """"""
+        lggg.FileHandler.__init__(self, path, *handler_args, **handler_kwargs)
+
+        self.extension = handler_extension_t(
+            name=name,
+            should_store_memory_usage=should_store_memory_usage,
+            handler=self,
+            level=level,
+            message_width=message_width,
+            formatter=formatter,
+        )
+
+        self.MessageFromRecord = self.extension.MessageFromRecord
+
+    def emit(self, record: lggg.LogRecord, /) -> None:
+        """"""
+        if hasattr(record, SHOW_W_RULE_ATTR):
+            message = RuleAsText(record.msg)
+        else:
+            message = self.MessageFromRecord(record)
+        print(message, file=self.stream)
+        self.stream.flush()
+
+    def ShowMessage(self, message: str, /, *, indented: bool = False) -> None:
+        """
+        See documentation of
+        logger_36.catalog.handler.generic.generic_handler_t.ShowMessage.
+        """
+        if indented:
+            message = txt_.indent(message, LINE_INDENT)
+        print(message, file=self.stream)
+        self.stream.flush()
+
+    def DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+        """"""
+        self.ShowMessage(RuleAsText(text))
+
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/catalog/handler/generic.py

@@ -0,0 +1,230 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import dataclasses as d
+import logging as lggg
+import typing as h
+
+try:
+    from logger_36.catalog.config.console_rich import DATE_TIME_COLOR
+    from logger_36.catalog.handler.console_rich import HighlightedVersion
+    from rich.console import Console as console_t  # noqa
+    from rich.console import ConsoleOptions as console_options_t  # noqa
+    from rich.markup import escape as EscapedForRich  # noqa
+    from rich.terminal_theme import DEFAULT_TERMINAL_THEME  # noqa
+except ModuleNotFoundError:
+    console_t = console_options_t = EscapedForRich = DEFAULT_TERMINAL_THEME = None
+
+from logger_36.constant.record import SHOW_W_RULE_ATTR
+from logger_36.task.format.rule import Rule, RuleAsText
+from logger_36.type.handler import handler_extension_t
+
+
+@h.runtime_checkable
+class show_message_p(h.Protocol):
+    def __call__(self, message: str, /, *, indented: bool = False) -> None: ...
+
+
+@h.runtime_checkable
+class display_rule_p(h.Protocol):
+    def __call__(self, /, *, text: str | None = None, color: str = "white") -> None: ...
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class generic_handler_t(lggg.Handler):
+    """
+    alternating_lines:
+        - Initial value:
+            - 1: enabled for dark background
+            - 2: enabled for light background
+            - anything else: disabled
+        - Runtime value: 0/1=do not/do highlight next time.
+
+    ShowMessage:
+        Log a message as is, i.e. without formatting. If this is a method, it should
+        contain the same call(s) as the final ones in the emit methods that are used to
+        output the formatted log messages. This means that there is some code
+        duplication, but it avoids a (maybe negligible) slowing down that would arise
+        from calling this method at the end of the emit methods.
+        Here, since, by definition, the generic handler does not know how to output
+        messages, it is a callable attribute that must be set at instantiation time, and
+        it is indeed called at the end of the emit method.
+    """
+
+    ShowMessage: show_message_p
+    # "None -> h.Any" (twice below) since None | None is invalid.
+    console: console_t | h.Any = None
+    console_options: console_options_t | h.Any = None
+    alternating_lines: int = 0
+    background_is_light: bool = True
+
+    DisplayRule: display_rule_p = d.field(init=False)
+    extension: handler_extension_t = d.field(init=False)
+    MessageFromRecord: h.Callable[..., tuple[str, str | None]] = d.field(init=False)
+
+    name: d.InitVar[str | None] = None
+    level: d.InitVar[int] = lggg.NOTSET
+    should_store_memory_usage: d.InitVar[bool] = False
+    message_width: d.InitVar[int] = -1
+    formatter: d.InitVar[lggg.Formatter | None] = None
+
+    supports_html: d.InitVar[bool] = False
+    should_record: d.InitVar[bool] = False
+    rich_kwargs: d.InitVar[dict[str, h.Any] | None] = None
+
+    def __post_init__(
+        self,
+        name: str | None,
+        level: int,
+        should_store_memory_usage: bool,
+        message_width: int,
+        formatter: lggg.Formatter | None,
+        supports_html: bool,
+        should_record: bool,
+        rich_kwargs: dict[str, h.Any] | None,
+    ) -> None:
+        """"""
+        lggg.Handler.__init__(self)
+
+        self.extension = handler_extension_t(
+            name=name,
+            should_store_memory_usage=should_store_memory_usage,
+            handler=self,
+            level=level,
+            message_width=message_width,
+            formatter=formatter,
+        )
+
+        if supports_html and (console_t is not None):
+            if rich_kwargs is None:
+                rich_kwargs = {}
+            self.console = console_t(
+                highlight=False,
+                force_terminal=True,
+                record=should_record,
+                **rich_kwargs,
+            )
+            self.console_options = self.console.options.update(
+                overflow="ignore", no_wrap=True
+            )
+            self.DisplayRule = self._DisplayRule
+        else:
+            self.DisplayRule = self._DisplayRuleAsText
+
+        self.MessageFromRecord = self.extension.MessageFromRecord
+        if self.alternating_lines == 1:
+            self.alternating_lines = 0
+            self.background_is_light = False
+        elif self.alternating_lines == 2:
+            self.alternating_lines = 0
+            self.background_is_light = True
+        else:
+            self.alternating_lines = -1
+
+    def emit(self, record: lggg.LogRecord, /) -> None:
+        """"""
+        if self.console is None:
+            if hasattr(record, SHOW_W_RULE_ATTR):
+                message = RuleAsText(record.msg)
+            else:
+                message = self.MessageFromRecord(record)
+        else:
+            if hasattr(record, SHOW_W_RULE_ATTR):
+                richer = Rule(record.msg, DATE_TIME_COLOR)
+            else:
+                message = self.MessageFromRecord(record, PreProcessed=EscapedForRich)
+                should_highlight_back = self.alternating_lines == 1
+                if self.alternating_lines >= 0:
+                    self.alternating_lines = (self.alternating_lines + 1) % 2
+                richer = HighlightedVersion(
+                    self.console,
+                    message,
+                    record.levelno,
+                    should_highlight_back=should_highlight_back,
+                    background_is_light=self.background_is_light,
+                )
+            segments = self.console.render(richer, options=self.console_options)
+
+            # Inspired from the code of: rich.console.export_html.
+            html_segments = []
+            for text, style, _ in segments:
+                if text == "\n":
+                    html_segments.append("\n")
+                else:
+                    if style is not None:
+                        style = style.get_html_style(DEFAULT_TERMINAL_THEME)
+                        if (style is not None) and (style.__len__() > 0):
+                            text = f'<span style="{style}">{text}</span>'
+                    html_segments.append(text)
+            if html_segments[-1] == "\n":
+                html_segments = html_segments[:-1]
+
+            # /!\ For some reason, the widget splits the message into lines, place each
+            # line inside a pre tag, and set margin-bottom of the first and list lines
+            # to 12px. This can be seen by printing self.contents.toHtml(). To avoid the
+            # unwanted extra margins, margin-bottom is set to 0 below.
+            message = (
+                "<pre style='margin-bottom:0px'>" + "".join(html_segments) + "</pre>"
+            )
+
+        self.ShowMessage(message)
+
+    def _DisplayRuleAsText(
+        self, /, *, text: str | None = None, color: str = "white"
+    ) -> None:
+        """"""
+        self.ShowMessage(RuleAsText(text))
+
+    def _DisplayRule(self, /, *, text: str | None = None, color: str = "white") -> None:
+        """"""
+        self.ShowMessage(Rule(text, color))
+
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/catalog/logger/chronos.py

@@ -0,0 +1,61 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+from logger_36.instance.logger import LOGGER
+from logger_36.task.measure.chronos import ElapsedTime
+from logger_36.type.logger import logger_t
+
+
+def LogElapsedTime(*, logger: logger_t = LOGGER) -> None:
+    """"""
+    logger.info(f"Elapsed Time: {ElapsedTime()}")
+
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/catalog/logger/gpu.py

@@ -0,0 +1,90 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import sys as sstm
+
+from logger_36.constant.error import GPU_LOGGING_ERROR
+from logger_36.instance.logger import LOGGER
+from logger_36.type.logger import logger_t
+
+try:
+    import tensorflow as tsfl  # noqa
+    import tensorrt as tsrt  # noqa
+
+    _GPU_LOGGING_ERROR = None
+except ModuleNotFoundError:
+    tsfl = tsrt = None
+    _GPU_LOGGING_ERROR = GPU_LOGGING_ERROR
+
+
+def LogGPURelatedDetails(*, logger: logger_t = LOGGER) -> None:
+    """"""
+    global _GPU_LOGGING_ERROR
+
+    if None in (tsfl, tsrt):
+        if _GPU_LOGGING_ERROR is not None:
+            print(_GPU_LOGGING_ERROR, file=sstm.stderr)
+            _GPU_LOGGING_ERROR = None
+        return
+
+    system_details = tsfl.sysconfig.get_build_info()
+    logger.info(
+        f"GPU-RELATED DETAILS\n"
+        f"                GPUs: {tsfl.config.list_physical_devices('GPU')}\n"
+        f"                CPUs: {tsfl.config.list_physical_devices('CPU')}\n"
+        f"                Cuda: {system_details['cuda_version']}\n"
+        f"               CuDNN: {system_details['cudnn_version']}\n"
+        f"          Tensorflow: {tsfl.version.VERSION}\n"
+        f"    Tensorflow Build: {tsfl.sysconfig.get_build_info()}\n"
+        f"            TensorRT: {tsrt.__version__}",
+    )
+
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""

logger_36/catalog/logger/memory.py

@@ -0,0 +1,129 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+from logger_36.config.memory import LENGTH_100, MAX_N_SAMPLES
+from logger_36.constant.memory import storage_units_h
+from logger_36.instance.logger import LOGGER
+from logger_36.task.format.memory import FormattedUsage, UsageBar
+from logger_36.task.format.message import MessageWithActualExpected
+from logger_36.type.logger import logger_t
+
+
+def LogMemoryUsages(
+    *,
+    unit: storage_units_h | None = "a",
+    decimals: int = None,
+    max_n_samples: int | None = MAX_N_SAMPLES,
+    length_100: int = LENGTH_100,
+    logger: logger_t = LOGGER,
+) -> None:
+    """"""
+    if not logger.any_handler_stores_memory:
+        return
+
+    where_s, usages = zip(*logger.memory_usages)
+
+    where, max_usage = logger.max_memory_usage_full
+    value, unit = FormattedUsage(max_usage, unit=unit, decimals=decimals)
+    title = f"Memory Usage: Max={value}{unit} near {where}\n"
+
+    if isinstance(max_n_samples, int):
+        if max_n_samples < 1:
+            raise ValueError(
+                MessageWithActualExpected(
+                    "Invalid maximum number of samples",
+                    actual=max_n_samples,
+                    expected=1,
+                    expected_op=">=",
+                )
+            )
+
+        where_s = list(where_s)
+        usages = list(usages)
+        while usages.__len__() > max_n_samples:
+            index = usages.index(min(usages))
+            del where_s[index]
+            del usages[index]
+
+    usages = tuple(round(_elm, 1) for _elm in usages)
+    max_usage = max(usages)
+
+    plot = []
+    max_where_length = max(map(len, where_s))
+    usages_as_str = tuple(map(lambda _elm: f"{_elm:_}", usages))
+    max_usage_length = max(map(len, usages_as_str))
+    for where, usage, usage_as_str in zip(where_s, usages, usages_as_str):
+        bar = UsageBar(usage, max_usage, length_100=length_100)
+        plot.append(
+            f"{where:{max_where_length}} "
+            f"{bar:{length_100}} "
+            f"{usage_as_str: >{max_usage_length}}"
+        )
+    plot = "\n".join(plot)
+
+    logger.info(title + plot)
+
+
+def LogMaximumMemoryUsage(
+    *,
+    unit: storage_units_h | None = "a",
+    decimals: int | None = None,
+    logger: logger_t = LOGGER,
+) -> None:
+    """
+    unit: b or None=bytes, k=kilo, m=mega, g=giga, a=auto
+    """
+    if logger.any_handler_stores_memory:
+        where, max_usage = logger.max_memory_usage_full
+        value, unit = FormattedUsage(max_usage, unit=unit, decimals=decimals)
+        logger.info(f"Max. Memory Usage: {value}{unit} near {where}")
+
+
+"""
+COPYRIGHT NOTICE
+
+This software is governed by the CeCILL  license under French law and
+abiding by the rules of distribution of free software.  You can  use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and  rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty  and the software's author,  the holder of the
+economic rights,  and the successive licensors  have only  limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+SEE LICENCE NOTICE: file README-LICENCE-utf8.txt at project source root.
+
+This software is being developed by Eric Debreuve, a CNRS employee and
+member of team Morpheme.
+Team Morpheme is a joint team between Inria, CNRS, and UniCA.
+It is hosted by the Centre Inria d'Université Côte d'Azur, Laboratory
+I3S, and Laboratory iBV.
+
+CNRS: https://www.cnrs.fr/index.php/en
+Inria: https://www.inria.fr/en/
+UniCA: https://univ-cotedazur.eu/
+Centre Inria d'Université Côte d'Azur: https://www.inria.fr/en/centre/sophia/
+I3S: https://www.i3s.unice.fr/en/
+iBV: http://ibv.unice.fr/
+Team Morpheme: https://team.inria.fr/morpheme/
+"""