str-to-obj 2024.1__py3-none-any.whl → 2024.2__py3-none-any.whl

str_to_obj/catalog/boolean.py

@@ -0,0 +1,73 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import typing as h
+from enum import Enum as enum_t
+
+from str_to_obj import annotation_t
+from str_to_obj.type.hint import annotated_hint_t
+
+
+class boolean_mode_e(enum_t):
+    # Always list true value first.
+    true_false = ("True", "False")
+    yes_no = ("Yes", "No")
+    on_off = ("On", "Off")
+
+
+_BOOLEAN_MODES = tuple(boolean_mode_e.__members__.keys())
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class boolean_t(annotation_t):
+
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (bool,)
+
+    mode: boolean_mode_e = boolean_mode_e.true_false
+
+    @classmethod
+    def NewAnnotatedType(
+        cls, /, *, mode: boolean_mode_e | str | None = None
+    ) -> annotated_hint_t:
+        """"""
+        if mode is None:
+            mode = boolean_mode_e.true_false
+        elif isinstance(mode, str):
+            if mode in _BOOLEAN_MODES:
+                mode = boolean_mode_e[mode].value
+            else:
+                valid = " or ".join(_BOOLEAN_MODES)
+                raise ValueError(
+                    f"Invalid boolean mode: Actual={mode}; Expected={valid}."
+                )
+
+        return h.Annotated[bool, cls(mode=mode)]

str_to_obj/catalog/callable.py

@@ -0,0 +1,75 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import typing as h
+
+from str_to_obj import annotation_t
+from str_to_obj.catalog.choices import choices_t
+from str_to_obj.type.hint import annotated_hint_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class callable_t(annotation_t):
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (str,)
+    DUMMY_ENTRY: h.ClassVar[str] = "Dummy entry"
+    SEPARATOR: h.ClassVar[str] = ":"
+    kind: h.Literal["class", "function"]
+    choices: choices_t | None = None
+    allow_external: bool = False
+
+    @classmethod
+    def NewAnnotatedType(
+        cls,
+        /,
+        *,
+        kind: h.Literal["class", "function"] = "function",
+        catalog: h.Sequence[str] | bool | None = None,
+        allow_external: bool = False,
+    ) -> annotated_hint_t:
+        """"""
+        if catalog is None:
+            annotation = cls(kind=kind, allow_external=allow_external)
+        elif isinstance(catalog, bool):
+            if catalog:
+                annotation = cls(
+                    kind=kind,
+                    choices=choices_t((cls.DUMMY_ENTRY,)),
+                    allow_external=allow_external,
+                )
+            else:
+                annotation = cls(kind=kind, allow_external=allow_external)
+        else:
+            annotation = cls(
+                kind=kind, choices=choices_t(catalog), allow_external=allow_external
+            )
+
+        return h.Annotated[str, annotation]

str_to_obj/catalog/choices.py

@@ -0,0 +1,76 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import typing as h
+
+from issue_manager import ISSUE_MANAGER
+from str_to_obj import annotation_t
+from str_to_obj.type.hint import annotated_hint_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class choices_t(annotation_t):
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (str,)
+    options: h.Sequence[str]
+
+    def __post_init__(self) -> None:
+        """"""
+        with ISSUE_MANAGER.AddedContextLevel("Choices Annotation"):
+            for option in self.options:
+                if not isinstance(option, str):
+                    ISSUE_MANAGER.Add(
+                        f'Invalid type of option "{option}"',
+                        actual=type(option).__name__,
+                        expected="str",
+                    )
+
+    @classmethod
+    def NewAnnotatedType(cls, options: h.Sequence[str], /) -> annotated_hint_t:
+        """"""
+        return h.Annotated[str, cls(tuple(options))]
+
+    def ValueIssues(self, value: str | h.Any, /) -> list[str]:
+        """"""
+        issues = annotation_t.ValueIssues(self, value)
+        if issues.__len__() > 0:
+            return issues
+
+        if (self.options.__len__() == 0) or (value in self.options):
+            # Options can be empty for a controlling parameter whose controlled section
+            # has not been specified. In a GUI context, such controlled section should
+            # have been populated programmatically.
+            return []
+
+        options = map(lambda _elm: f'"{_elm}"', self.options)
+        options = " or ".join(options)
+
+        return [f"Invalid choice: Actual={value}; Expected={options}."]

str_to_obj/catalog/collection.py

@@ -0,0 +1,154 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import types as t
+import typing as h
+
+from issue_manager import ISSUE_MANAGER
+from str_to_obj import annotation_t
+from str_to_obj.type.hint import any_hint_h
+from str_to_obj.type.type import type_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class collection_t(annotation_t):
+    # 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,)
+
+    ACCEPTED_TYPES: h.ClassVar[tuple[type, ...]] = (list, set, tuple)
+    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 ISSUE_MANAGER.AddedContextLevel("Collection Annotation"):
+            if isinstance(self.items_types, h.Sequence):
+                if max(self.lengths) > self.items_types.__len__():
+                    ISSUE_MANAGER.Add(
+                        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):
+                        ISSUE_MANAGER.Add(
+                            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, ...],
+        /,
+    ) -> collection_t:
+        """"""
+        if not isinstance(stripe, (type_t | tuple[type_t, ...])):
+            stripe = type_t.NewForHint(stripe)
+
+        if stripe.type not in cls.ACCEPTED_TYPES:
+            with ISSUE_MANAGER.AddedContextLevel("Collection Annotation"):
+                ISSUE_MANAGER.Add(
+                    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

str_to_obj/catalog/number.py

@@ -0,0 +1,120 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import typing as h
+
+from issue_manager import ISSUE_MANAGER
+from str_to_obj import annotation_t
+
+number_h = int | float
+
+
+@dtcl.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 ISSUE_MANAGER.AddedContextLevel("Number Annotation"):
+            if (self.min != stripe.INFINITY_NEG) and not isinstance(
+                self.min, number_h.__args__
+            ):
+                ISSUE_MANAGER.Add(
+                    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__
+            ):
+                ISSUE_MANAGER.Add(
+                    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__
+            ):
+                ISSUE_MANAGER.Add(
+                    f"Invalid type for precision {self.precision}",
+                    actual=type(self.precision).__name__,
+                    expected=number_h,
+                )
+            if self.precision < 0:
+                ISSUE_MANAGER.Add(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 = "["
+                ISSUE_MANAGER.Add(
+                    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."]

str_to_obj/catalog/path.py

@@ -0,0 +1,94 @@
+# Copyright CNRS/Inria/UniCA
+# 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
+import typing as h
+from enum import Enum as enum_t
+from pathlib import Path as pl_path_t
+
+from str_to_obj 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
+
+
+@dtcl.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."
+        ]

str_to_obj/interface/console.py

@@ -29,10 +29,10 @@
 # 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
+import typing as h
 
 
-def TypeAsRichStr(value: Any, /, *, prefix: str = "") -> str:
+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 +46,10 @@ 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}"

str_to_obj/main.py

@@ -30,8 +30,8 @@
 # knowledge of the CeCILL license and that you accept its terms.
 
 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
@@ -41,13 +41,13 @@ 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_tree_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:

str_to_obj/runtime/type.py

@@ -0,0 +1,36 @@
+# 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 typing as h
+
+from str_to_obj.type.type import any_type_t
+
+ANY_TYPE = any_type_t.NewForHint(h.Any)

str_to_obj/runtime/value.py

@@ -0,0 +1,34 @@
+# 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 str_to_obj.type.value import invalid_value_t
+
+INVALID_VALUE = invalid_value_t()

str_to_obj/task/casting.py

@@ -32,9 +32,9 @@
 from __future__ import annotations
 
 import dataclasses as dtcl
+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
@@ -55,7 +55,7 @@ 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)
@@ -63,15 +63,15 @@ class _value_tree_t(_value_node_t):
     elements: tuple[_value_tree_t, ...] = None
 
     @classmethod
-    def NewFromValue(cls, value: Any, /) -> _value_tree_t:
+    def NewFromValue(cls, value: h.Any, /) -> _value_tree_t:
         """"""
-        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)
@@ -80,7 +80,7 @@ class _value_tree_t(_value_node_t):
 
     def CastValue(
         self, hint_tree: hint_tree_t, /, *, only_check_validity: bool = False
-    ) -> tuple[Any, list[str]] | list[str]:
+    ) -> tuple[h.Any, list[str]] | list[str]:
         """"""
         issues = self._CastToHint(hint_tree)
         if issues.__len__() > 0:
@@ -102,10 +102,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 +113,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 +167,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 +179,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)
         )
@@ -208,17 +213,21 @@ class _value_tree_t(_value_node_t):
         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_tree_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)
+        hint = hint_tree_t.NewForHint(hint)
 
     return value_tree.CastValue(hint, only_check_validity=only_check_validity)

str_to_obj/task/comparison.py

@@ -29,8 +29,8 @@
 # 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 types as t
 import typing as h
-from types import UnionType
 
 from str_to_obj.type.hint_tree import hint_tree_t
 
@@ -47,12 +47,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

str_to_obj/task/inspection.py

@@ -29,7 +29,7 @@
 # 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
+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,7 +45,9 @@ 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):
@@ -56,7 +58,7 @@ def AnnotationsOfAnnotatedHint(annotated_hint: annotated_hint_t, /) -> tuple[Any
     )
 
 
-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)

str_to_obj/type/annotation.py

@@ -30,20 +30,16 @@
 # knowledge of the CeCILL license and that you accept its terms.
 
 import dataclasses as dtcl
-from typing import Any, ClassVar
+import typing as h
 
 from rich.text import Text as text_t
-
-from str_to_obj.interface.console import (
-    NameValueTypeAsRichStr,
-    TypeAsRichStr,
-)
+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)
 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 +53,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))

str_to_obj/type/hint.py

@@ -29,14 +29,14 @@
 # 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
+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 +44,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 +54,4 @@ 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

str_to_obj/type/hint_tree.py

@@ -33,8 +33,8 @@ from __future__ import annotations
 
 import dataclasses as dtcl
 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 str_to_obj.task.inspection import HintComponents
 from str_to_obj.type.annotation import annotation_t
@@ -52,7 +52,7 @@ class _hint_node_t:
     Leave elements to the tree.
     """
 
-    type: non_complex_hint_h | UnionType | EllipsisType | type[NoneType]
+    type: non_complex_hint_h | t.UnionType | t.EllipsisType | type[t.NoneType]
     annotations: tuple[annotation_t, ...] = dtcl.field(default_factory=tuple)
 
 
@@ -61,9 +61,7 @@ class hint_tree_t(_hint_node_t):
     elements: tuple[hint_tree_t, ...] = 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, /) -> hint_tree_t:
         """
         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
@@ -80,24 +78,24 @@ class hint_tree_t(_hint_node_t):
 
         # 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.")
 
-        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,12 +110,12 @@ 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:
@@ -143,12 +141,12 @@ class hint_tree_t(_hint_node_t):
         """"""
         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
 

str_to_obj/type/type.py

@@ -0,0 +1,97 @@
+# Copyright CNRS/Inria/UniCA
+# Contributor(s): Eric Debreuve (since 2021)
+#
+# 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
+import typing as h
+
+from rich.text import Text as text_t
+from str_to_obj import CastValue, ObjectFromStr, annotation_t
+from str_to_obj.runtime.value import INVALID_VALUE
+from str_to_obj.type.hint_tree import hint_tree_t
+
+
+@dtcl.dataclass(slots=True, repr=False, eq=False)
+class type_t(hint_tree_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) + "[/]"
+
+
+@dtcl.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, []

str_to_obj/type/value.py

@@ -0,0 +1,47 @@
+# Copyright CNRS/Inria/UniCA
+# Contributor(s): Eric Debreuve (since 2021)
+#
+# 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.
+
+
+class invalid_value_t:
+    """
+    Do not use invalid_value_t = object, for example, otherwise isinstance returns True
+    for anything.
+    """
+
+    TEXT = "INVALID VALUE"
+
+    def __str__(self) -> str:
+        """"""
+        return self.__class__.TEXT
+
+    def __rich__(self) -> str:
+        """"""
+        return f"[red]{self.__class__.TEXT}[/]"

str_to_obj/version.py

@@ -29,6 +29,6 @@
 # The fact that you are presently reading this means that you have had
 # knowledge of the CeCILL license and that you accept its terms.
 
-__version__ = "2024.1"
+__version__ = "2024.2"
 
 # TODO: Switch to issue-manager.

{str_to_obj-2024.1.dist-info → str_to_obj-2024.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: str-to-obj
-Version: 2024.1
+Version: 2024.2
 Summary: Convert strings to Python objects guided by (potentially annotated) type hints
 Home-page: https://src.koda.cnrs.fr/eric.debreuve/str-to-obj/
 Author: Eric Debreuve

str_to_obj-2024.2.dist-info/RECORD

@@ -0,0 +1,24 @@
+str_to_obj/__init__.py,sha256=odgBU079fpQMu9GXhY0Lc19Rris-8Oa60Dd4F5SxGpQ,1735
+str_to_obj/main.py,sha256=ZcH2KpO9AO6Ozoroin_KkY78P5kV625sALf-ffbIOkE,2481
+str_to_obj/version.py,sha256=d_xwIXU-KduqN957zZV4jgOF0cvsoXCMoiHAWH2TF68,1609
+str_to_obj/catalog/boolean.py,sha256=-1k39odWGgm42cotKxdV00i_M4UbKByK_V8gawgYmjY,2724
+str_to_obj/catalog/callable.py,sha256=mYj-qNGY0ncvFBNzzbphb0hOF1YMqPaXX1iRr6rev1c,2985
+str_to_obj/catalog/choices.py,sha256=CxBngQYiC7Pct-sLQHmtDaPr93gt_H_DreO9-s3Znv0,3176
+str_to_obj/catalog/collection.py,sha256=rOUtBkfL6KV05HtkHaMOrTls0bXRIq1lCECLvN_B37Q,6193
+str_to_obj/catalog/number.py,sha256=UmUkOwnwNZyNxDeXzm_rZHFHpnzc5ovg3Us47Uord5c,4840
+str_to_obj/catalog/path.py,sha256=rri5nZbZClINC__VzS4a6CpRvaLvkSVqcattuWGP9Ys,3217
+str_to_obj/interface/console.py,sha256=YF95b31qPqzeG4lnYtoJ7awQM3QDSOhIjZUeadGd7L4,2406
+str_to_obj/runtime/type.py,sha256=diT38JyuZHJb5-uzIf97s9iDzp_ADyLto5LGg0H3tyc,1657
+str_to_obj/runtime/value.py,sha256=cj7RvdAEy9Xc6INaGGq0CirjZ9gv-moFFUlXuFbzvP8,1637
+str_to_obj/task/casting.py,sha256=0CEVkXXLR9-8ilL3IbnrTTWx-q8Wvkx1VLPVEuCXgx8,8601
+str_to_obj/task/comparison.py,sha256=j6YHHRrkR2oucQnwshl0fMQm7ReuaJFVpwqMHgld5X0,2562
+str_to_obj/task/inspection.py,sha256=9wllLu9WmkB3LfduBnT4Wa47M4UzGy5bJK9OTnPfOgI,2494
+str_to_obj/type/annotation.py,sha256=dmLMtOnbP4NP7pPYEy9r7YhHF21EoTyz2BaO4vkB7qk,3216
+str_to_obj/type/hint.py,sha256=jlQgGosqoszkreJYFS_pga5RpqrUiLYALoxtzrB5rPU,2180
+str_to_obj/type/hint_tree.py,sha256=-24_WCPX94K5ryY6DZKV-_4vnTyaqPV3vJ-OVX-iuxQ,6052
+str_to_obj/type/type.py,sha256=6KZgHRKZi1zzJ9KiW2LLvUXVr0EALUM4Yz8cwvgFeBg,3459
+str_to_obj/type/value.py,sha256=9sXtYf0kVHVpcczS_ZtVZa9_M17pIlYSZjYYE33sS1Y,1904
+str_to_obj-2024.2.dist-info/METADATA,sha256=ujALfzQppSFkyY2oPL2AdazmE1TvWHGpNVbkR6zCVhk,5389
+str_to_obj-2024.2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+str_to_obj-2024.2.dist-info/top_level.txt,sha256=h-6bR_TAnXRGVSLTeNPlivlaG64xYM3E__Xg7sCgeug,11
+str_to_obj-2024.2.dist-info/RECORD,,

{str_to_obj-2024.1.dist-info → str_to_obj-2024.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

str_to_obj-2024.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-str_to_obj/__init__.py,sha256=odgBU079fpQMu9GXhY0Lc19Rris-8Oa60Dd4F5SxGpQ,1735
-str_to_obj/main.py,sha256=YxjO1kyeZxGf_31KRZVZ39F7gr0gYM1OyOa7Y8m4iG8,2488
-str_to_obj/version.py,sha256=rlojaXevssZP7Crmyq2gSWwZ5xM-WJW9n3iVSVFSO18,1609
-str_to_obj/interface/console.py,sha256=PHcDGFmscXYSrPOJRjmlBPglQUBBGUhe1Bov3pthGT0,2414
-str_to_obj/task/casting.py,sha256=74eIRKpokqq-JqEK0UwRSQs1F4Zdj8pRDQXAPkqg3Ug,8468
-str_to_obj/task/comparison.py,sha256=-1xreDu25SrWyTEGwcZMctURj2A47zAh2QJdMf4EuTg,2568
-str_to_obj/task/inspection.py,sha256=dwaK4uMN5iPgcWWVnFu86eSkuPy1G_phBAGTqEa_414,2488
-str_to_obj/type/annotation.py,sha256=bR7tQVfYmAohizn4APx_D0aNoPo6gMjyFRoa-QpDNKM,3241
-str_to_obj/type/hint.py,sha256=Jv3m1VbXICsUwPTCFidW6A1bX-xgNU2twRP_H1DX5v4,2221
-str_to_obj/type/hint_tree.py,sha256=1Gp4I6kgRGshKQJBurJF0wbG02xv-d5Spe2f-4h19qk,6113
-str_to_obj-2024.1.dist-info/METADATA,sha256=_AkIgj6_TGFJvuo0wvmP5Hdnuk9Z8jtbxbo_OaqmuQU,5389
-str_to_obj-2024.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-str_to_obj-2024.1.dist-info/top_level.txt,sha256=h-6bR_TAnXRGVSLTeNPlivlaG64xYM3E__Xg7sCgeug,11
-str_to_obj-2024.1.dist-info/RECORD,,