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

str_to_obj/runtime/type.py

@@ -0,0 +1,58 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import typing as h
+
+from str_to_obj.type.type import any_type_t
+
+ANY_TYPE = any_type_t.NewForHint(h.Any)
+
+
+"""
+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/runtime/value.py

@@ -0,0 +1,56 @@
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+from str_to_obj.type.value import invalid_value_t
+
+INVALID_VALUE = invalid_value_t()
+
+
+"""
+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/task/casting.py

@@ -1,43 +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
-
-import dataclasses as dtcl
+"""
+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 pathlib import Path as path_t
-from types import EllipsisType, NoneType, UnionType
-from typing import Any, Iterable
 
 from str_to_obj.type.hint import any_hint_h, simple_hint_h
-from str_to_obj.type.hint_tree import hint_tree_t
+from str_to_obj.type.hint_tree import hint_t
 
 
 class _not_a_leaf_node_t:
@@ -47,7 +20,7 @@ class _not_a_leaf_node_t:
 _NOT_A_LEAF_NODE = _not_a_leaf_node_t()
 
 
-@dtcl.dataclass(slots=True, repr=False, eq=False)
+@d.dataclass(slots=True, repr=False, eq=False)
 class _value_node_t:
     """
     Leave elements to the tree.
@@ -55,23 +28,23 @@ class _value_node_t:
     """
 
     type: simple_hint_h = None
-    leaf_value: Any | None = _NOT_A_LEAF_NODE
+    leaf_value: h.Any | None = _NOT_A_LEAF_NODE
 
 
-@dtcl.dataclass(slots=True, repr=False, eq=False)
+@d.dataclass(slots=True, repr=False, eq=False)
 class _value_tree_t(_value_node_t):
-    elements: tuple[_value_tree_t, ...] = None
+    elements: tuple[h.Self, ...] = None
 
     @classmethod
-    def NewFromValue(cls, value: Any, /) -> _value_tree_t:
+    def NewFromValue(cls, value: h.Any, /) -> h.Self:
         """"""
-        if isinstance(value, Iterable) and not isinstance(value, str):
+        if isinstance(value, h.Iterable) and not isinstance(value, str):
             elements = tuple(cls.NewFromValue(_elm) for _elm in value)
             return cls(type=type(value), elements=elements)
 
         return cls(leaf_value=value)
 
-    def _RebuiltValue(self) -> Any:
+    def _RebuiltValue(self) -> h.Any:
         """"""
         if self.leaf_value is _NOT_A_LEAF_NODE:
             return self.type(_elm._RebuiltValue() for _elm in self.elements)
@@ -79,8 +52,8 @@ class _value_tree_t(_value_node_t):
         return self.leaf_value
 
     def CastValue(
-        self, hint_tree: hint_tree_t, /, *, only_check_validity: bool = False
-    ) -> tuple[Any, list[str]] | list[str]:
+        self, hint_tree: hint_t, /, *, only_check_validity: bool = False
+    ) -> tuple[h.Any, list[str]] | list[str]:
         """"""
         issues = self._CastToHint(hint_tree)
         if issues.__len__() > 0:
@@ -94,7 +67,7 @@ class _value_tree_t(_value_node_t):
         else:
             return self._RebuiltValue(), []
 
-    def _CastToHint(self, hint_node: hint_tree_t, /) -> list[str]:
+    def _CastToHint(self, hint_node: hint_t, /) -> list[str]:
         """
         Returned value=the value tree has been successfully cast to the hint tree
         specification, or not.
@@ -102,10 +75,10 @@ class _value_tree_t(_value_node_t):
         hn_type = hint_node.type
         hn_elements = hint_node.elements
 
-        if hn_type is Any:
+        if hn_type is h.Any:
             return self._CompliesWithAnnotations(hint_node)
 
-        if hn_type is NoneType:
+        if hn_type is t.NoneType:
             # None is not supposed to have annotations. They are ignored if it does.
             if self.leaf_value is None:
                 output = []
@@ -113,7 +86,7 @@ class _value_tree_t(_value_node_t):
                 output = [f"{self.leaf_value}: Invalid value; Expected=None."]
             return output
 
-        if hn_type is UnionType:
+        if hn_type is t.UnionType:
             issues = []
             for element in hn_elements:
                 local_issues = self._CastToHint(element)
@@ -167,8 +140,11 @@ class _value_tree_t(_value_node_t):
                 rebuilt = self._RebuiltValue()
                 try:
                     _ = hn_type(rebuilt)
-                except:
-                    return [f"{rebuilt}: Cannot be cast to type {hn_type.__name__}."]
+                except Exception as exception:
+                    return [
+                        f"{rebuilt}: Cannot be cast to type {hn_type.__name__} "
+                        f"({exception.__class__.__name__})."
+                    ]
                 else:
                     self.type = hn_type
 
@@ -176,7 +152,9 @@ class _value_tree_t(_value_node_t):
 
         n_value_elements = self.elements.__len__()
         n_hint_elements = hn_elements.__len__()
-        has_ellipsis = (n_hint_elements == 2) and (hn_elements[1].type is EllipsisType)
+        has_ellipsis = (n_hint_elements == 2) and (
+            hn_elements[1].type is t.EllipsisType
+        )
         should_fake_ellipsis = (n_hint_elements == 1) and issubclass(
             hn_type, (list, set)
         )
@@ -203,22 +181,73 @@ class _value_tree_t(_value_node_t):
             f"Expected=Value following template {hint_node.template_as_str}."
         ]
 
-    def _CompliesWithAnnotations(self, hint_node: hint_tree_t, /) -> list[str]:
+    def _CompliesWithAnnotations(self, hint_node: hint_t, /) -> list[str]:
         """"""
         output = []
 
         for annotation in hint_node.annotations:
-            output.extend(annotation.ValueIsCompliant(self._RebuiltValue()))
+            output.extend(annotation.ValueIssues(self._RebuiltValue()))
 
         return output
 
 
 def CastValue(
-    value: Any, hint: any_hint_h | hint_tree_t, /, *, only_check_validity: bool = False
-) -> tuple[Any, list[str]] | list[str]:
+    value: h.Any,
+    hint: any_hint_h | hint_t,
+    /,
+    *,
+    only_check_validity: bool = False,
+) -> tuple[h.Any, list[str]] | list[str]:
     """"""
     value_tree = _value_tree_t.NewFromValue(value)
-    if not isinstance(hint, hint_tree_t):
-        hint = hint_tree_t.NewFromTypeHint(hint)
+    if not isinstance(hint, hint_t):
+        hint = hint_t.NewForHint(hint)
 
     return value_tree.CastValue(hint, only_check_validity=only_check_validity)
+
+
+"""
+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/task/comparison.py

@@ -1,43 +1,18 @@
-# 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 types as t
 import typing as h
-from types import UnionType
 
-from str_to_obj.type.hint_tree import hint_tree_t
+from str_to_obj.type.hint_tree import hint_t
 
 
 def TypesAreCompatible(
-    one: hint_tree_t,
-    another: hint_tree_t,
+    one: hint_t,
+    another: hint_t,
     /,
     *,
     strict_mode: bool = True,
@@ -47,12 +22,12 @@ def TypesAreCompatible(
     if h.Any in (one.type, another.type):
         return True
 
-    if one.type is UnionType:
+    if one.type is t.UnionType:
         return any(
             TypesAreCompatible(_elm, another, strict_mode=strict_mode)
             for _elm in one.elements
         )
-    if another.type is UnionType:
+    if another.type is t.UnionType:
         return any(
             TypesAreCompatible(one, _elm, strict_mode=strict_mode)
             for _elm in another.elements
@@ -66,3 +41,50 @@ def TypesAreCompatible(
         return issubclass(one.type, another.type)
 
     return issubclass(one.type, another.type) or issubclass(another.type, one.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/task/inspection.py

@@ -1,35 +1,10 @@
-# 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
+"""
+Copyright CNRS/Inria/UniCA
+Contributor(s): Eric Debreuve (eric.debreuve@cnrs.fr) since 2023
+SEE COPYRIGHT NOTICE BELOW
+"""
+
+import typing as h
 
 from str_to_obj.type.annotation import annotation_t
 from str_to_obj.type.hint import annotated_hint_t, any_hint_h, raw_hint_h
@@ -45,20 +20,69 @@ def TypeOfAnnotatedHint(annotated_hint: annotated_hint_t, /) -> raw_hint_h:
     return annotated_hint.__args__[0]
 
 
-def AnnotationsOfAnnotatedHint(annotated_hint: annotated_hint_t, /) -> tuple[Any, ...]:
+def AnnotationsOfAnnotatedHint(
+    annotated_hint: annotated_hint_t, /
+) -> tuple[h.Any, ...]:
     """"""
     output = tuple(annotated_hint.__metadata__)
     if all(isinstance(_elm, annotation_t) for _elm in output):
         return output
 
     raise ValueError(
-        f'{output}: Not all elements are of type "{annotation_t.__name__}".'
+        f'Not all elements of {output} are of type "{annotation_t.__name__}".'
     )
 
 
-def HintComponents(hint: any_hint_h, /) -> tuple[raw_hint_h, tuple[Any, ...]]:
+def HintComponents(hint: any_hint_h, /) -> tuple[raw_hint_h, tuple[h.Any, ...]]:
     """"""
     if IsAnnotated(hint):
         return TypeOfAnnotatedHint(hint), AnnotationsOfAnnotatedHint(hint)
 
     return hint, ()
+
+
+"""
+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/
+"""