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

str_to_obj/catalog/collection.py

@@ -0,0 +1,175 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import dataclasses as d
+import types as t
+import typing as h
+
+from logger_36 import LOGGER
+from str_to_obj.type.annotation import annotation_t
+from str_to_obj.type.hint import any_hint_h
+from str_to_obj.type.type import type_t
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class collection_t(annotation_t):
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (list, set, tuple)
+
+    # Items of any type but None.
+    ANY_ITEMS_TYPES: h.ClassVar[h.Any | tuple[h.Any, ...]] = h.Any
+    ANY_LENGTH: h.ClassVar[tuple[int, ...]] = (0,)
+
+    items_types: any_hint_h | tuple[any_hint_h, ...] | type_t | tuple[type_t, ...] = (
+        ANY_ITEMS_TYPES
+    )
+    lengths: int | tuple[int, ...] = ANY_LENGTH
+
+    def __post_init__(self) -> None:
+        """"""
+        original_item_types = self.items_types
+        original_lengths = self.lengths
+
+        if isinstance(self.items_types, h.Sequence):
+            items_types = []
+            for stripe in self.items_types:
+                if isinstance(stripe, type_t):
+                    items_types.append(stripe)
+                else:
+                    items_types.append(type_t.NewForHint(stripe))
+            self.items_types = items_types
+        elif not isinstance(self.items_types, type_t):
+            self.items_types = type_t.NewForHint(self.items_types)
+
+        if isinstance(self.lengths, int):
+            self.lengths = (self.lengths,)
+        else:
+            self.lengths = tuple(sorted(self.lengths))
+
+        with LOGGER.AddedContextLevel("Collection Annotation"):
+            if isinstance(self.items_types, h.Sequence):
+                if max(self.lengths) > self.items_types.__len__():
+                    LOGGER.StageIssue(
+                        f'Allowed length(s) ("{original_lengths}") must not exceed '
+                        f"the length of the item types sequence "
+                        f'("{original_item_types}")'
+                    )
+            if self.lengths != self.__class__.ANY_LENGTH:
+                for length in self.lengths:
+                    if (not isinstance(length, int)) or (length < 0):
+                        LOGGER.StageIssue(
+                            f"Invalid length in {self.lengths}",
+                            actual=length,
+                            expected="strictly positive integer",
+                        )
+
+    @classmethod
+    def NewForType(
+        cls,
+        stripe: any_hint_h | tuple[any_hint_h, ...] | type_t | tuple[type_t, ...],
+        /,
+    ) -> h.Self:
+        """"""
+        if not isinstance(stripe, (type_t | tuple[type_t, ...])):
+            stripe = type_t.NewForHint(stripe)
+
+        if stripe.type not in cls.ACCEPTED_TYPES:
+            with LOGGER.AddedContextLevel("Collection Annotation"):
+                LOGGER.StageIssue(
+                    f"Invalid type",
+                    actual=stripe.type.__name__,
+                    expected=", ".join(_elm.__name__ for _elm in cls.ACCEPTED_TYPES),
+                )
+                return collection_t()
+
+        if stripe.elements is None:
+            return collection_t()
+
+        if (n_elements := stripe.elements.__len__()) == 1:
+            return collection_t(items_types=stripe.elements[0], lengths=1)
+
+        if (n_elements == 2) and (stripe.elements[1].type is t.EllipsisType):
+            return collection_t(items_types=stripe.elements[0], lengths=cls.ANY_LENGTH)
+
+        return collection_t(items_types=stripe.elements, lengths=n_elements)
+
+    def ValueIssues(self, value: list | set | tuple | h.Any, /) -> list[str]:
+        """"""
+        issues = annotation_t.ValueIssues(self, value)
+        if issues.__len__() > 0:
+            return issues
+
+        if (self.lengths != self.__class__.ANY_LENGTH) and (
+            value.__len__() not in self.lengths
+        ):
+            return [
+                f"{value}: Sequence of invalid length; "
+                f"Expected={' or '.join(map(str, self.lengths))}."
+            ]
+
+        if isinstance(self.items_types, h.Sequence):
+            if value.__len__() > self.items_types.__len__():
+                return [
+                    f"{value}: Sequence too long. "
+                    f"Expected=At most {self.items_types.__len__()} element(s)."
+                ]
+
+            output = []
+            for stripe, element in zip(self.items_types, value):
+                output.extend(stripe.ValueIssues(element))
+            return output
+
+        stripe: type_t = self.items_types
+        output = []
+        for element in value:
+            output.extend(stripe.ValueIssues(element))
+        return 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/catalog/number.py

@@ -0,0 +1,142 @@
+"""
+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 logger_36 import LOGGER
+from str_to_obj.type.annotation import annotation_t
+
+number_h = int | float
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class number_t(annotation_t):
+    INFINITY_NEG: h.ClassVar[float] = -float("inf")
+    INFINITY_POS: h.ClassVar[float] = float("inf")
+    INFINITE_PRECISION: h.ClassVar[float] = 0.0
+
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (int, float)
+    min: number_h = INFINITY_NEG
+    max: number_h = INFINITY_POS
+    min_inclusive: bool = True
+    max_inclusive: bool = True
+    precision: number_h = INFINITE_PRECISION
+
+    def __post_init__(self) -> None:
+        """"""
+        stripe = self.__class__
+
+        with LOGGER.AddedContextLevel("Number Annotation"):
+            if (self.min != stripe.INFINITY_NEG) and not isinstance(
+                self.min, number_h.__args__
+            ):
+                LOGGER.StageIssue(
+                    f"Invalid type for min value {self.min}",
+                    actual=type(self.min).__name__,
+                    expected=number_h,
+                )
+            if (self.max != stripe.INFINITY_POS) and not isinstance(
+                self.max, number_h.__args__
+            ):
+                LOGGER.StageIssue(
+                    f"Invalid type for max value {self.max}",
+                    actual=type(self.max).__name__,
+                    expected=number_h,
+                )
+            if (self.precision != stripe.INFINITE_PRECISION) and not isinstance(
+                self.precision, number_h.__args__
+            ):
+                LOGGER.StageIssue(
+                    f"Invalid type for precision {self.precision}",
+                    actual=type(self.precision).__name__,
+                    expected=number_h,
+                )
+            if self.precision < 0:
+                LOGGER.StageIssue(f"Invalid, negative precision {self.precision}")
+            if (self.min > self.max) or (
+                (self.min == self.max)
+                and not (self.min_inclusive and self.max_inclusive)
+            ):
+                if self.min_inclusive:
+                    opening = "["
+                else:
+                    opening = "]"
+                if self.max_inclusive:
+                    closing = "]"
+                else:
+                    closing = "["
+                LOGGER.StageIssue(
+                    f"Empty value interval {opening}{self.min},{self.max}{closing}"
+                )
+
+    def ValueIssues(self, value: number_h, /) -> list[str]:
+        """"""
+        issues = annotation_t.ValueIssues(self, value)
+        if issues.__len__() > 0:
+            return issues
+
+        if self.min <= value <= self.max:
+            if ((value == self.min) and not self.min_inclusive) or (
+                (value == self.max) and not self.max_inclusive
+            ):
+                return [f"{value}: Value outside prescribed interval."]
+
+            if (self.precision != self.__class__.INFINITE_PRECISION) and (
+                self.precision * int(value / self.precision) != value
+            ):
+                return [f"{value}: Value of higher precision than the prescribed one."]
+
+            return []
+        else:
+            return [f"{value}: Value outside prescribed interval."]
+
+
+"""
+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/catalog/path.py

@@ -0,0 +1,117 @@
+"""
+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 enum import Enum as enum_t
+from pathlib import Path as pl_path_t
+
+from str_to_obj.type.annotation import annotation_t
+from str_to_obj.type.hint import annotated_hint_t
+
+
+class path_type_e(enum_t):
+    document = 1
+    folder = 2
+    any = 3
+
+
+class path_purpose_e(enum_t):
+    input = 1
+    output = 2
+    any = 3
+
+
+@d.dataclass(slots=True, repr=False, eq=False)
+class path_t(annotation_t):
+
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (pl_path_t,)
+
+    type_: path_type_e
+    purpose: path_purpose_e
+
+    @classmethod
+    def NewAnnotatedType(
+        cls, type_: path_type_e, purpose: path_purpose_e, /
+    ) -> annotated_hint_t:
+        """"""
+        return h.Annotated[pl_path_t, cls(type_=type_, purpose=purpose)]
+
+    def ValueIssues(self, value: pl_path_t | h.Any, /) -> list[str]:
+        """
+        None: Unspecified path.
+        """
+        issues = annotation_t.ValueIssues(self, value)
+        if issues.__len__() > 0:
+            return issues
+
+        if self.purpose is not path_purpose_e.input:
+            return []
+
+        if value.exists():
+            if self.type_ is path_type_e.any:
+                if value.is_file() or value.is_dir():
+                    return []
+                else:
+                    return [f"{value}: Not a valid file or folder."]
+
+            if (self.type_ is path_type_e.document) and value.is_file():
+                return []
+
+            if (self.type_ is path_type_e.folder) and value.is_dir():
+                return []
+
+        return [
+            f"{value}: Non-existent file or folder, or file for folder, "
+            f"or folder for file."
+        ]
+
+
+"""
+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/interface/console.py

@@ -1,38 +1,13 @@
-# 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 typing import Any, Sequence
-
-
-def TypeAsRichStr(value: Any, /, *, prefix: str = "") -> str:
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import typing as h
+
+
+def TypeAsRichStr(value: h.Any, /, *, prefix: str = "") -> str:
     """
     Richer alternative (however, causes troubles with packages like TensorFlow):
     Additional parameter: relative_to_home: bool = True
@@ -46,10 +21,57 @@ def TypeAsRichStr(value: Any, /, *, prefix: str = "") -> str:
     return f"[yellow]{prefix}{type(value).__name__}[/]"
 
 
-def NameValueTypeAsRichStr(name: str, value: Any, /, *, separator: str = "=") -> str:
+def NameValueTypeAsRichStr(name: str, value: h.Any, /, *, separator: str = "=") -> str:
     """"""
     formatted_type = TypeAsRichStr(value, prefix=":")
-    if isinstance(value, Sequence) and (value.__len__() == 0):
+    if isinstance(value, h.Sequence) and (value.__len__() == 0):
         value = "[cyan]<empty>[/]"
 
     return f"[blue]{name}[/]{separator}{value}{formatted_type}"
+
+
+"""
+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/main.py

@@ -1,59 +1,35 @@
-# 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.
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
 
 import ast as bstr
-from types import NoneType
-from typing import Any
+import types as t
+import typing as h
 
 from str_to_obj.task.casting import CastValue
-from str_to_obj.type.hint_tree import any_hint_h, hint_tree_t
+from str_to_obj.type.hint_tree import any_hint_h, hint_t
 
 
 def ObjectFromStr(
     string: str,
     /,
     *,
-    expected_type: any_hint_h | hint_tree_t | type[NoneType] = None,
-) -> tuple[Any, list[str]]:
+    expected_type: any_hint_h | hint_t | type[t.NoneType] = None,
+) -> tuple[h.Any, list[str]]:
     """
     expected_type: Must not be passed explicitly as None since None is interpreted as
     "no specific expected type". When expecting None, pass NoneType.
     """
-    if expected_type is NoneType:
+    if expected_type is t.NoneType:
         if string.lower() == "none":
             issues = []
         else:
             issues = [f'{string}: Invalid value; Expected="NONE" or "None" or "none".']
         return None, issues
 
+    # value = _ObjectFromStr(string)
     try:
         value = bstr.literal_eval(string)
     except (SyntaxError, ValueError):
@@ -63,3 +39,67 @@ def ObjectFromStr(
         return value, []
 
     return CastValue(value, expected_type)
+
+
+# def _ObjectFromStr(string: str | h.Any, /)-> h.Any:
+#     """"""
+#     # if not isinstance(string, str):
+#     #     return string
+#
+#     try:
+#         value = bstr.literal_eval(string)
+#     except (SyntaxError, ValueError):
+#         value = string
+#
+#     # if isinstance(value, h.Sequence) and not isinstance(value, str):
+#     #     stripe = type(value)
+#     #     value = stripe(_ObjectFromStr(_elm) for _elm in value)
+#
+#     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/
+"""