str-to-obj 2024.1__tar.gz → 2024.3__tar.gz

{str_to_obj-2024.1 → str_to_obj-2024.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: str-to-obj
-Version: 2024.1
+Version: 2024.3
 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.1 → str_to_obj-2024.3}/setup.py

@@ -73,7 +73,9 @@ PYPI_STATUS = "4 - Beta"      # https://pypi.org/classifiers/    Development Sta
 IMPORT_NAME = "str_to_obj"
 PACKAGES = [
     IMPORT_NAME,
+    f"{IMPORT_NAME}.catalog",
     f"{IMPORT_NAME}.interface",
+    f"{IMPORT_NAME}.runtime",
     f"{IMPORT_NAME}.task",
     f"{IMPORT_NAME}.type",
 ]

{str_to_obj-2024.1 → str_to_obj-2024.3}/str_to_obj/__init__.py

@@ -30,6 +30,8 @@
 # knowledge of the CeCILL license and that you accept its terms.
 
 from str_to_obj.main import ObjectFromStr
+from str_to_obj.runtime.value import INVALID_VALUE
 from str_to_obj.task.casting import CastValue
 from str_to_obj.type.annotation import annotation_t
+from str_to_obj.type.type import type_t
 from str_to_obj.version import __version__

str_to_obj-2024.3/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-2024.3/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-2024.3/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-2024.3/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-2024.3/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-2024.3/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-2024.1 → str_to_obj-2024.3}/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-2024.1 → str_to_obj-2024.3}/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: