str-to-obj 2023.10__py3-none-any.whl → 2025.1__py3-none-any.whl

str_to_obj/type/annotation.py

@@ -1,49 +1,20 @@
-# Copyright CNRS/Inria/UNS
-# Contributor(s): Eric Debreuve (since 2023)
-#
-# eric.debreuve@cnrs.fr
-#
-# 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.
-
-import dataclasses as dtcl
-from typing import Any, ClassVar
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
 
-from rich.text import Text as text_t
+import dataclasses as d
+import typing as h
 
-from str_to_obj.interface.console import (
-    NameValueTypeAsRichStr,
-    TypeAsRichStr,
-)
+from rich.text import Text as text_t
+from str_to_obj.interface.console import NameValueTypeAsRichStr, TypeAsRichStr
 from str_to_obj.type.hint import annotated_hint_t, non_complex_hint_h
 
 
-@dtcl.dataclass(slots=True, repr=False, eq=False)
+@d.dataclass(slots=True, repr=False, eq=False)
 class annotation_t:
-    ACCEPTED_TYPES: ClassVar[tuple[non_complex_hint_h, ...]] = (Any,)
+    ACCEPTED_TYPES: h.ClassVar[tuple[non_complex_hint_h, ...]] = (h.Any,)
 
     @classmethod
     def NewAnnotatedType(cls, *args, **kwargs) -> annotated_hint_t:
@@ -57,11 +28,11 @@ class annotation_t:
         """
         raise NotImplementedError
 
-    def ValueIsCompliant(self, value: Any, /) -> list[str]:
+    def ValueIssues(self, value: h.Any, /) -> list[str]:
         """"""
         types = self.__class__.ACCEPTED_TYPES
         stripe = type(value)
-        if (Any in types) or (stripe in types) or issubclass(stripe, types):
+        if (h.Any in types) or (stripe in types) or issubclass(stripe, types):
             return []
 
         expected = " or ".join(map(str, types))
@@ -77,9 +48,56 @@ class annotation_t:
         """"""
         output = [TypeAsRichStr(self)]
 
-        names = (_fld.name for _fld in dtcl.fields(self))
+        names = (_fld.name for _fld in d.fields(self))
         for name in names:
             value = getattr(self, name)
             output.append(f"    {NameValueTypeAsRichStr(name, value, separator=' = ')}")
 
         return "\n".join(output)
+
+
+"""
+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/
+"""

str_to_obj/type/hint.py

@@ -1,42 +1,17 @@
-# Copyright CNRS/Inria/UNS
-# Contributor(s): Eric Debreuve (since 2023)
-#
-# eric.debreuve@cnrs.fr
-#
-# 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.
-
-from types import EllipsisType, GenericAlias, UnionType
-from typing import Annotated, Any
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import types as t
+import typing as h
 
 # --- Unannotated hints
 # Atoms
-generic_hint_h = Any
-simple_hint_h = type[Any]
-complex_hint_h = GenericAlias | UnionType
+generic_hint_h = h.Any
+simple_hint_h = type[h.Any]
+complex_hint_h = t.GenericAlias | t.UnionType
 
 # Grouping
 non_complex_hint_h = generic_hint_h | simple_hint_h
@@ -44,7 +19,7 @@ raw_hint_h = non_complex_hint_h | complex_hint_h
 
 
 # --- Annotated hints
-annotated_hint_t = type(Annotated[object, None])
+annotated_hint_t = type(h.Annotated[object, None])
 
 
 # --- [Un]Annotated hints
@@ -54,4 +29,50 @@ any_hint_h = raw_hint_h | annotated_hint_t
 # --- Complex hints additional components:
 #     - EllipsisType for GenericAlias, as in: tuple[int, ...]
 #     - None for UnionType, as in: int | None
-complex_hint_additions_h = EllipsisType | None
+complex_hint_additions_h = t.EllipsisType | None
+
+"""
+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/
+"""

str_to_obj/type/hint_tree.py

@@ -1,41 +1,16 @@
-# Copyright CNRS/Inria/UNS
-# Contributor(s): Eric Debreuve (since 2023)
-#
-# eric.debreuve@cnrs.fr
-#
-# 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.
-
-from __future__ import annotations
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
 
-import dataclasses as dtcl
+import dataclasses as d
 import re as regx
-from types import EllipsisType, NoneType, UnionType
-from typing import Any, Union, get_args, get_origin
+import types as t
+import typing as h
 
+from logger_36.content import MessageWithActualExpected
+from str_to_obj.catalog.choices import choices_t
 from str_to_obj.task.inspection import HintComponents
 from str_to_obj.type.annotation import annotation_t
 from str_to_obj.type.hint import (
@@ -46,24 +21,29 @@ from str_to_obj.type.hint import (
 )
 
 
-@dtcl.dataclass(slots=True, repr=False, eq=False)
+@d.dataclass(slots=True, repr=False, eq=False)
 class _hint_node_t:
     """
     Leave elements to the tree.
+    literal_s: the accepted (literal) values if the hint is a typing.Literal, None
+    otherwise.
     """
 
-    type: non_complex_hint_h | UnionType | EllipsisType | type[NoneType]
-    annotations: tuple[annotation_t, ...] = dtcl.field(default_factory=tuple)
+    type: non_complex_hint_h | t.UnionType | t.EllipsisType | type[t.NoneType]
+    annotations: tuple[annotation_t, ...] = d.field(default_factory=tuple)
+    literal_s: tuple[h.Any, ...] | None = None
 
 
-@dtcl.dataclass(slots=True, repr=False, eq=False)
-class hint_tree_t(_hint_node_t):
-    elements: tuple[hint_tree_t, ...] = None
+@d.dataclass(slots=True, repr=False, eq=False)
+class hint_t(_hint_node_t):
+    """
+    elements: tuple if the hint is a container, None otherwise. In terms of tree
+    structure, it plays the role of the (hint) node children.
+    """
+    elements: tuple[h.Self, ...] | None = None
 
     @classmethod
-    def NewFromTypeHint(
-        cls, hint: any_hint_h | complex_hint_additions_h, /
-    ) -> hint_tree_t:
+    def NewForHint(cls, hint: any_hint_h | complex_hint_additions_h, /) -> h.Self:
         """
         Note that type hints cannot translate into hint trees with an OR-node having a child
         OR-node. For example: str | (int | float) is interpreted as str | int | float. This
@@ -74,30 +54,50 @@ class hint_tree_t(_hint_node_t):
         if isinstance(hint, annotation_t):
             # This is a common mistake in specifications.
             raise ValueError(
-                f'{hint}: Invalid hint type "{type(hint).__name__}"; '
-                f"Expected={any_hint_h}."
+                MessageWithActualExpected(
+                    "Invalid hint type", actual=type(hint).__name__, expected=any_hint_h
+                )
             )
 
-        # Dealing with complex_hint_additions_h first
+        # Dealing with complex_hint_additions_h first.
         if hint is Ellipsis:
-            return cls(type=EllipsisType)
-        if (hint is None) or (hint is NoneType):
-            return cls(type=NoneType)
+            return cls(type=t.EllipsisType)
+        if (hint is None) or (hint is t.NoneType):
+            return cls(type=t.NoneType)
 
         # nnts: Do not use "annotations" since it shadows __future__.annotations.
         raw_hint, nnts = HintComponents(hint)
 
-        if (origin := get_origin(raw_hint)) is None:
+        if (origin := h.get_origin(raw_hint)) is None:
             return cls(type=raw_hint, annotations=nnts)
 
         # Handled types: list, set, tuple, with sets using the dict delimiters { and }.
         if origin is dict:
-            raise TypeError(f"{origin.__name__}: Unhandled type.")
+            raise TypeError(f"Unhandled type: {origin.__name__}.")
+
+        if origin is h.Literal:
+            literal_s = h.get_args(raw_hint)
+            if any(isinstance(_elm, choices_t) for _elm in nnts):
+                raise ValueError(
+                    f"Literal hint with values {literal_s} "
+                    f"must not be annotated with {choices_t.__name__} as it leads to "
+                    f"either redundancy or mismatch."
+                )
+            stripes = tuple(set(type(_elm) for _elm in literal_s))
+            if stripes.__len__() > 1:
+                origin = t.UnionType
+                elements = tuple(cls.NewForHint(_elm) for _elm in stripes)
+            else:
+                origin = stripes[0]
+                elements = None
+            return cls(
+                type=origin, annotations=nnts, elements=elements, literal_s=literal_s
+            )
 
-        if origin is Union:
-            origin = UnionType
+        if origin is h.Union:
+            origin = t.UnionType
         # get_args returns NoneType for None. This must be taken into account above.
-        elements = tuple(cls.NewFromTypeHint(_elm) for _elm in get_args(raw_hint))
+        elements = tuple(cls.NewForHint(_elm) for _elm in h.get_args(raw_hint))
         return cls(type=origin, annotations=nnts, elements=elements)
 
     @property
@@ -112,30 +112,43 @@ class hint_tree_t(_hint_node_t):
         return output
 
     @property
-    def template(self) -> simple_hint_h | dict[int, Any] | None:
+    def template(self) -> simple_hint_h | dict[int, h.Any] | None:
         """"""
-        if self.type is NoneType:
+        if self.type is t.NoneType:
             return None
 
-        if self.type is UnionType:
+        if self.type is t.UnionType:
             return {_key: _elm.template for _key, _elm in enumerate(self.elements)}
 
         if self.elements is None:
             return self.type
 
-        return self.type(_elm.template for _elm in self.elements)
+        try:
+            output = self.type(_elm.template for _elm in self.elements)
+        except TypeError:
+            output = None
+        if output is not None:
+            return output
+
+        # TODO: Does it work all the time?
+        if self.elements.__len__() == 1:
+            # For example, self.type is typing.Sequence.
+            return self.type[self.elements[0].template]
+
+        # TODO: Can something better be done?
+        return self.type
 
     @property
     def template_as_str(self) -> str:
         """"""
         output = (
             str(self.template)
-            .replace(str(EllipsisType), "...")
+            .replace(str(t.EllipsisType), "...")
             .replace("<class '", "")
             .replace("'>", "")
         )
-        output = regx.sub("{\d: ", "{", output, flags=regx.ASCII)
-        output = regx.sub(", \d:", " |", output, flags=regx.ASCII)
+        output = regx.sub(r"{\d: ", "{", output, flags=regx.ASCII)
+        output = regx.sub(r", \d:", " |", output, flags=regx.ASCII)
 
         return output
 
@@ -149,7 +162,7 @@ class hint_tree_t(_hint_node_t):
 #     """"""
 #     output = [TypeAsRichStr(self)]
 #
-#     names = (_fld.name for _fld in dtcl.fields(self))
+#     names = (_fld.name for _fld in d.fields(self))
 #     for name in names:
 #         value = getattr(self, name)
 #         output.append(f"    {NameValueTypeAsRichStr(name, value, separator='@=@')}")
@@ -157,3 +170,49 @@ class hint_tree_t(_hint_node_t):
 #     output = AlignedOnSeparator(output, "@=@", " = ")
 #
 #     return "\n".join(output)
+
+"""
+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/
+"""

str_to_obj/type/type.py

@@ -0,0 +1,121 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import dataclasses as d
+import typing as h
+
+from rich.text import Text as text_t
+from str_to_obj.main import ObjectFromStr
+from str_to_obj.runtime.value import INVALID_VALUE
+from str_to_obj.task.casting import CastValue
+from str_to_obj.type.annotation import annotation_t
+from str_to_obj.type.hint_tree import hint_t
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class type_t(hint_t):
+    def FirstAnnotationWithType(
+        self, stripe: type[annotation_t], /
+    ) -> annotation_t | None:
+        """"""
+        for annotation in self.all_annotations:
+            if isinstance(annotation, stripe):
+                return annotation
+
+        return None
+
+    def ValueIssues(self, value: h.Any, /) -> list[str]:
+        """"""
+        return CastValue(value, self, only_check_validity=True)
+
+    def InterpretedValueOf(self, value: h.Any, /) -> tuple[h.Any, list[str]]:
+        """"""
+        if isinstance(value, str):
+            typed_value, issues = ObjectFromStr(value, expected_type=self)
+        else:
+            typed_value, issues = CastValue(value, self)
+
+        if issues.__len__() > 0:
+            return INVALID_VALUE, issues
+
+        return typed_value, []
+
+    def __str__(self) -> str:
+        """"""
+        return text_t.from_markup(self.__rich__()).plain
+
+    def __rich__(self) -> str:
+        """"""
+        output = [f"[white]{self.template_as_str}[/]"]
+
+        for annotation in self.all_annotations:
+            output.append(type(annotation).__name__)
+
+        return "[yellow]" + "::".join(output) + "[/]"
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class any_type_t(type_t):
+    def FirstAnnotationWithType(
+        self, stripe: type[annotation_t], /
+    ) -> annotation_t | None:
+        """"""
+        return None
+
+    def ValueIssues(self, _: h.Any, /) -> list[str]:
+        """"""
+        return []
+
+    def InterpretedValueOf(self, value: h.Any, /) -> tuple[h.Any, list[str]]:
+        """"""
+        return value, []
+
+
+"""
+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/
+"""