dycw-utilities 0.112.1__tar.gz → 0.112.2__tar.gz

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.112.1
+Version: 0.112.2
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.112.1"
+version = "0.112.2"
 
 [project.optional-dependencies]
 test = [
@@ -337,7 +337,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.112.1"
+current_version = "0.112.2"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/tests/test_dataclasses.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import NoneType
-from typing import Any, cast, override
+from typing import Any, Literal, cast, override
 
 from hypothesis import given
 from hypothesis.strategies import booleans, integers, lists, sampled_from
@@ -406,7 +406,18 @@ class TestSerializeAndParseDataClass:
         assert result == obj
 
     @given(int_=integers())
-    def test_extra_type(self, *, int_: int) -> None:
+    def test_literal_type(self, *, int_: int) -> None:
+        obj = DataClassFutureInt(int_=int_)
+        serialized = serialize_dataclass(obj)
+        result = parse_dataclass(
+            serialized,
+            DataClassFutureInt,
+            extra_parsers={Literal["lit"]: NotImplementedError},
+        )
+        assert result == obj
+
+    @given(int_=integers())
+    def test_type_extra(self, *, int_: int) -> None:
         obj = DataClassFutureNestedOuterFirstOuter(
             inner=DataClassFutureNestedOuterFirstInner(int_=int_)
         )
@@ -625,9 +636,8 @@ class TestYieldFields:
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (TrueOrFalseFutureLit,)
-        arg = one(args)
-        assert get_args(arg) == ("true", "false")
+        assert args == (TrueOrFalseFutureLit, NoneType)
+        assert get_args(args[0]) == ("true", "false")
 
     def test_class_future_nested(self) -> None:
         result = one(
@@ -665,9 +675,8 @@ class TestYieldFields:
         assert result == expected
         assert is_optional_type(result.type_)
         args = get_args(result.type_)
-        assert args == (TrueOrFalseFutureTypeLit,)
-        arg = one(args)
-        assert get_args(arg) == ("true", "false")
+        assert args == (TrueOrFalseFutureTypeLit, NoneType)
+        assert get_args(args[0]) == ("true", "false")
 
     def test_class_orjson_log_record(self) -> None:
         result = list(yield_fields(OrjsonLogRecord, globalns=globals()))

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/tests/test_parse.py

@@ -57,6 +57,7 @@ from utilities.parse import (
     serialize_object,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.text import parse_bool
 from utilities.types import Duration, Number
 from utilities.version import Version
 
@@ -98,28 +99,17 @@ class TestSerializeAndParseObject:
         result = parse_object(TruthEnum, serialized)
         assert result is truth
 
-    @given(int_=integers())
-    def test_extra_type(self, *, int_: int) -> None:
-        serialized = serialize_object(int_)
-        result = parse_object(
-            DataClassFutureInt,
-            serialized,
-            extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
-        )
-        expected = DataClassFutureInt(int_=int_)
-        assert result == expected
-
     @given(float_=floats())
     def test_float(self, *, float_: float) -> None:
         serialized = serialize_object(float_)
         result = parse_object(float, serialized)
         assert is_equal(result, float_)
 
-    @given(values=frozensets(dates()))
-    def test_frozenset(self, *, values: frozenset[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=frozensets(dates()))
+    def test_frozenset(self, *, dates: frozenset[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(frozenset[dt.date], serialized)
-        assert result == values
+        assert result == dates
 
     @given(int_=integers())
     def test_int(self, *, int_: int) -> None:
@@ -127,11 +117,17 @@ class TestSerializeAndParseObject:
         result = parse_object(int, serialized)
         assert result == int_
 
-    @given(values=lists(dates()))
-    def test_list(self, *, values: list[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=lists(dates()))
+    def test_list(self, *, dates: list[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(list[dt.date], serialized)
-        assert result == values
+        assert result == dates
+
+    @given(bool_=booleans())
+    def test_literal_extra(self, *, bool_: bool) -> None:
+        text = serialize_object(bool_)
+        result = parse_object(bool, text, extra={Literal["lit"]: parse_bool})
+        assert result is bool_
 
     @given(truth=sampled_from(["true", "false"]))
     def test_literal(self, *, truth: Literal["true", "false"]) -> None:
@@ -205,11 +201,11 @@ class TestSerializeAndParseObject:
         result = parse_object(Sentinel, serialized)
         assert result is sentinel
 
-    @given(values=sets(dates()))
-    def test_set(self, *, values: set[dt.date]) -> None:
-        serialized = serialize_object(values)
+    @given(dates=sets(dates()))
+    def test_set(self, *, dates: set[dt.date]) -> None:
+        serialized = serialize_object(dates)
         result = parse_object(set[dt.date], serialized)
-        assert result == values
+        assert result == dates
 
     @given(serialized=text_ascii())
     def test_to_serialized(self, *, serialized: str) -> None:
@@ -234,6 +230,17 @@ class TestSerializeAndParseObject:
         result = parse_object(tuple[int, int], serialized)
         assert result == (x, y)
 
+    @given(int_=integers())
+    def test_type_extra(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
+        result = parse_object(
+            DataClassFutureInt,
+            serialized,
+            extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
+        )
+        expected = DataClassFutureInt(int_=int_)
+        assert result == expected
+
     @given(truth=sampled_from(["true", "false"]))
     def test_type_literal(self, *, truth: Literal["true", "false"]) -> None:
         result = parse_object(TrueOrFalseFutureTypeLit, truth)

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/tests/test_sentinel.py

@@ -26,11 +26,12 @@ class TestParseSentinel:
         result = parse_sentinel(text_use)
         assert result is sentinel
 
-    def test_error(self) -> None:
+    @given(text=sampled_from(["invalid", "ssentinell"]))
+    def test_error(self, *, text: str) -> None:
         with raises(
-            ParseSentinelError, match="Unable to parse sentinel value; got 'invalid'"
+            ParseSentinelError, match="Unable to parse sentinel value; got '.*'"
         ):
-            _ = parse_sentinel("invalid")
+            _ = parse_sentinel(text)
 
 
 class TestSentinel:

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/tests/test_text.py

@@ -51,11 +51,10 @@ class TestParseBool:
         result = parse_bool(text_use)
         assert result is value
 
-    def test_error(self) -> None:
-        with raises(
-            ParseBoolError, match="Unable to parse boolean value; got 'invalid'"
-        ):
-            _ = parse_bool("invalid")
+    @given(text=sampled_from(["invalid", "11", "00", "ttruee", "ffalsee"]))
+    def test_error(self, *, text: str) -> None:
+        with raises(ParseBoolError, match="Unable to parse boolean value; got '.*'"):
+            _ = parse_bool(text)
 
 
 class TestParseNone:
@@ -66,9 +65,10 @@ class TestParseNone:
         result = parse_none(text_use)
         assert result is None
 
-    def test_error(self) -> None:
-        with raises(ParseNoneError, match="Unable to parse null value; got 'invalid'"):
-            _ = parse_none("invalid")
+    @given(text=sampled_from(["invalid", "nnonee"]))
+    def test_error(self, *, text: str) -> None:
+        with raises(ParseNoneError, match="Unable to parse null value; got '.*'"):
+            _ = parse_none(text)
 
 
 class TestReprEncode:

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/tests/test_typing.py

@@ -22,8 +22,10 @@ from hypothesis.strategies import (
     just,
     none,
     sampled_from,
+    sets,
+    tuples,
 )
-from pytest import mark, param, raises
+from pytest import raises
 
 from tests.test_typing_funcs.no_future import (
     DataClassNoFutureNestedInnerFirstInner,
@@ -54,6 +56,7 @@ from tests.test_typing_funcs.with_future import (
 from utilities.sentinel import Sentinel
 from utilities.types import Duration, LogLevel, Number, Parallelism, Seed
 from utilities.typing import (
+    IsSubclassGenError,
     _GetTypeClassesTupleError,
     _GetTypeClassesTypeError,
     _GetUnionTypeClassesInternalTypeError,
@@ -85,32 +88,40 @@ if TYPE_CHECKING:
 
 
 class TestContainsSelf:
-    @mark.parametrize("obj", [param(Self), param(Self | None)])
+    @given(obj=sampled_from([Self, Self | None]))
     def test_main(self, *, obj: Any) -> None:
         assert contains_self(obj)
 
 
 class TestGetArgs:
-    @mark.parametrize(
-        ("obj", "expected"),
-        [
-            param(dict[int, int], (int, int)),
-            param(frozenset[int], (int,)),
-            param(int | None, (int,)),
-            param(int | str, (int, str)),
-            param(list[int], (int,)),
-            param(Literal["a", "b", "c"], ("a", "b", "c")),
-            param(Mapping[int, int], (int, int)),
-            param(Sequence[int], (int,)),
-            param(set[int], (int,)),
-            param(LogLevel, ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")),
-            param(Parallelism, ("processes", "threads")),
-        ],
+    @given(
+        case=sampled_from([
+            (dict[int, int], (int, int)),
+            (frozenset[int], (int,)),
+            (int | None, (int, NoneType)),
+            (int | str, (int, str)),
+            (list[int], (int,)),
+            (Literal["a", "b", "c"], ("a", "b", "c")),
+            (Mapping[int, int], (int, int)),
+            (Sequence[int], (int,)),
+            (set[int], (int,)),
+            (LogLevel, ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")),
+            (Parallelism, ("processes", "threads")),
+        ])
     )
-    def test_main(self, *, obj: Any, expected: tuple[Any, ...]) -> None:
+    def test_main(self, *, case: tuple[Any, tuple[Any, ...]]) -> None:
+        obj, expected = case
         result = get_args(obj)
         assert result == expected
 
+    @given(case=sampled_from([(int | None, (int,)), (int | str | None, (int, str))]))
+    def test_optional_drop_none(
+        self, *, case: tuple[Any, tuple[type[Any], ...]]
+    ) -> None:
+        obj, expected = case
+        result = get_args(obj, optional_drop_none=True)
+        assert result == expected
+
 
 type _PlusOrMinusOneLit = Literal[1, -1]
 type _TruthLit = Literal["true", "false"]
@@ -417,73 +428,71 @@ class TestGetUnionTypeClasses:
 
 
 class TestIsAnnotationOfType:
-    @mark.parametrize(
-        ("func", "obj", "expected"),
-        [
-            param(is_dict_type, Mapping[int, int], False),
-            param(is_dict_type, Sequence[int], False),
-            param(is_dict_type, dict[int, int], True),
-            param(is_dict_type, frozenset[int], False),
-            param(is_dict_type, list[int], False),
-            param(is_dict_type, set[int], False),
-            param(is_dict_type, tuple[int, int], False),
-            param(is_frozenset_type, Mapping[int, int], False),
-            param(is_frozenset_type, Sequence[int], False),
-            param(is_frozenset_type, dict[int, int], False),
-            param(is_frozenset_type, frozenset[int], True),
-            param(is_frozenset_type, list[int], False),
-            param(is_frozenset_type, set[int], False),
-            param(is_frozenset_type, tuple[int, int], False),
-            param(is_list_type, Mapping[int, int], False),
-            param(is_list_type, Sequence[int], False),
-            param(is_list_type, dict[int, int], False),
-            param(is_list_type, frozenset[int], False),
-            param(is_list_type, list[int], True),
-            param(is_list_type, set[int], False),
-            param(is_list_type, tuple[int, int], False),
-            param(is_literal_type, Literal["a", "b", "c"], True),
-            param(is_literal_type, list[int], False),
-            param(is_mapping_type, Mapping[int, int], True),
-            param(is_mapping_type, Sequence[int], False),
-            param(is_mapping_type, dict[int, int], False),
-            param(is_mapping_type, frozenset[int], False),
-            param(is_mapping_type, list[int], False),
-            param(is_mapping_type, set[int], False),
-            param(is_mapping_type, tuple[int, int], False),
-            param(is_optional_type, Literal["a", "b", "c"] | None, True),
-            param(is_optional_type, Literal["a", "b", "c"], False),
-            param(is_optional_type, int | None, True),
-            param(is_optional_type, int | str, False),
-            param(is_optional_type, list[int] | None, True),
-            param(is_optional_type, list[int], False),
-            param(is_sequence_type, Mapping[int, int], False),
-            param(is_sequence_type, Sequence[int], True),
-            param(is_sequence_type, dict[int, int], False),
-            param(is_sequence_type, frozenset[int], False),
-            param(is_sequence_type, list[int], False),
-            param(is_sequence_type, set[int], False),
-            param(is_sequence_type, tuple[int, int], False),
-            param(is_set_type, Mapping[int, int], False),
-            param(is_set_type, Sequence[int], False),
-            param(is_set_type, dict[int, int], False),
-            param(is_set_type, frozenset[int], False),
-            param(is_set_type, list[int], False),
-            param(is_set_type, set[int], True),
-            param(is_set_type, tuple[int, int], False),
-            param(is_tuple_type, Mapping[int, int], False),
-            param(is_tuple_type, Sequence[int], False),
-            param(is_tuple_type, dict[int, int], False),
-            param(is_tuple_type, frozenset[int], False),
-            param(is_tuple_type, list[int], False),
-            param(is_tuple_type, set[int], False),
-            param(is_tuple_type, tuple[int, int], True),
-            param(is_union_type, int | str, True),
-            param(is_union_type, list[int], False),
-        ],
+    @given(
+        case=sampled_from([
+            (is_dict_type, Mapping[int, int], False),
+            (is_dict_type, Sequence[int], False),
+            (is_dict_type, dict[int, int], True),
+            (is_dict_type, frozenset[int], False),
+            (is_dict_type, list[int], False),
+            (is_dict_type, set[int], False),
+            (is_dict_type, tuple[int, int], False),
+            (is_frozenset_type, Mapping[int, int], False),
+            (is_frozenset_type, Sequence[int], False),
+            (is_frozenset_type, dict[int, int], False),
+            (is_frozenset_type, frozenset[int], True),
+            (is_frozenset_type, list[int], False),
+            (is_frozenset_type, set[int], False),
+            (is_frozenset_type, tuple[int, int], False),
+            (is_list_type, Mapping[int, int], False),
+            (is_list_type, Sequence[int], False),
+            (is_list_type, dict[int, int], False),
+            (is_list_type, frozenset[int], False),
+            (is_list_type, list[int], True),
+            (is_list_type, set[int], False),
+            (is_list_type, tuple[int, int], False),
+            (is_literal_type, Literal["a", "b", "c"], True),
+            (is_literal_type, list[int], False),
+            (is_mapping_type, Mapping[int, int], True),
+            (is_mapping_type, Sequence[int], False),
+            (is_mapping_type, dict[int, int], False),
+            (is_mapping_type, frozenset[int], False),
+            (is_mapping_type, list[int], False),
+            (is_mapping_type, set[int], False),
+            (is_mapping_type, tuple[int, int], False),
+            (is_optional_type, Literal["a", "b", "c"] | None, True),
+            (is_optional_type, Literal["a", "b", "c"], False),
+            (is_optional_type, int | None, True),
+            (is_optional_type, int | str, False),
+            (is_optional_type, list[int] | None, True),
+            (is_optional_type, list[int], False),
+            (is_sequence_type, Mapping[int, int], False),
+            (is_sequence_type, Sequence[int], True),
+            (is_sequence_type, dict[int, int], False),
+            (is_sequence_type, frozenset[int], False),
+            (is_sequence_type, list[int], False),
+            (is_sequence_type, set[int], False),
+            (is_sequence_type, tuple[int, int], False),
+            (is_set_type, Mapping[int, int], False),
+            (is_set_type, Sequence[int], False),
+            (is_set_type, dict[int, int], False),
+            (is_set_type, frozenset[int], False),
+            (is_set_type, list[int], False),
+            (is_set_type, set[int], True),
+            (is_set_type, tuple[int, int], False),
+            (is_tuple_type, Mapping[int, int], False),
+            (is_tuple_type, Sequence[int], False),
+            (is_tuple_type, dict[int, int], False),
+            (is_tuple_type, frozenset[int], False),
+            (is_tuple_type, list[int], False),
+            (is_tuple_type, set[int], False),
+            (is_tuple_type, tuple[int, int], True),
+            (is_union_type, int | str, True),
+            (is_union_type, list[int], False),
+        ])
     )
-    def test_main(
-        self, *, func: Callable[[Any], bool], obj: Any, expected: bool
-    ) -> None:
+    def test_main(self, *, case: tuple[Callable[[Any], bool], Any, bool]) -> None:
+        func, obj, expected = case
         assert func(obj) is expected
 
 
@@ -491,27 +500,52 @@ class TestIsInstanceGen:
     @given(
         data=data(),
         case=sampled_from([
-            (booleans(), bool, True),
-            (booleans(), int, False),
-            (integers(), bool, False),
-            (integers(), int, True),
-            (booleans(), (bool, int), True),
-            (integers(), (bool, int), True),
-            (dates(), dt.date, True),
-            (dates(), dt.datetime, False),
-            (datetimes(), dt.date, False),
-            (datetimes(), dt.datetime, True),
-            (booleans(), Number, False),
-            (integers(), Number, True),
-            (floats(), Number, True),
+            (booleans(), bool, None, True),
+            (booleans(), int, None, False),
+            (integers(), bool, None, False),
+            (integers(), int, None, True),
+            (booleans(), (bool, int), None, True),
+            (integers(), (bool, int), None, True),
+            (dates(), dt.date, None, True),
+            (dates(), dt.datetime, None, False),
+            (datetimes(), dt.date, None, False),
+            (datetimes(), dt.datetime, None, True),
+            (booleans(), Number, None, False),
+            (integers(), Number, None, True),
+            (floats(), Number, None, True),
+            (tuples(booleans()), (bool,), None, True),
+            (tuples(booleans()), (int,), None, False),
+            (tuples(integers()), (bool,), None, False),
+            (tuples(integers()), (int,), None, True),
+            (tuples(integers()), (int, int), None, False),
+            (integers(), int | None, None, True),
+            (integers() | none(), int, None, False),
+            (integers() | none(), int | None, None, True),
+            (sampled_from([1, 2]), Literal[1, 2, 3], 2, True),
+            (sampled_from([1, 2, 3]), Literal[1, 2, 3], 3, True),
+            (sampled_from([1, 2, 3]), Literal[1, 2], 3, False),
+            (booleans(), Literal[1, 2, 3], None, False),
+            (sampled_from([1, 2, 3]), bool, 3, False),
+            (tuples(booleans()), Literal[1, 2, 3], None, False),
+            (sampled_from([1, 2, 3]), (bool,), 3, False),
         ]),
     )
     def test_main(
-        self, *, data: DataObject, case: tuple[SearchStrategy[Any], Any, bool]
+        self,
+        *,
+        data: DataObject,
+        case: tuple[SearchStrategy[Any], Any, int | None, bool],
     ) -> None:
-        strategy, type_, expected = case
-        value = data.draw(strategy)
-        assert is_instance_gen(value, type_) is expected
+        strategy, type_, min_size, expected = case
+        match expected:
+            case True:
+                value = data.draw(strategy)
+                assert is_instance_gen(value, type_)
+            case False:
+                values = data.draw(
+                    sets(strategy, min_size=100 if min_size is None else min_size)
+                )
+                assert not all(is_instance_gen(v, type_) for v in values)
 
     @given(bool_=booleans())
     def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
@@ -560,6 +594,21 @@ class TestIsSubclassGen:
             (bool, Number, False),
             (int, Number, True),
             (float, Number, True),
+            ((bool,), (bool,), True),
+            ((bool,), (int,), False),
+            ((int,), (bool,), False),
+            ((int,), (int,), True),
+            ((int,), (int, int), False),
+            (int, int | None, True),
+            (int | None, int, False),
+            (int | None, int | None, True),
+            (Literal[1, 2], Literal[1, 2, 3], True),
+            (Literal[1, 2, 3], Literal[1, 2, 3], True),
+            (Literal[1, 2, 3], Literal[1, 2], False),
+            (bool, Literal[1, 2, 3], False),
+            (Literal[1, 2, 3], bool, False),
+            ((bool,), Literal[1, 2, 3], False),
+            (Literal[1, 2, 3], (bool,), False),
         ])
     )
     def test_main(self, *, case: tuple[type[Any], Any, bool]) -> None:
@@ -574,3 +623,7 @@ class TestIsSubclassGen:
         assert not is_subclass_gen(int, MyInt)
         assert is_subclass_gen(MyInt, int)
         assert is_subclass_gen(MyInt, MyInt)
+
+    def test_error(self) -> None:
+        with raises(IsSubclassGenError, match="Argument must be a class; got None"):
+            _ = is_subclass_gen(None, NoneType)

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.112.1"
+__version__ = "0.112.2"

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/utilities/polars.py

@@ -941,10 +941,9 @@ def dataclass_to_schema(
             dtype = struct_dtype(**dtypes)
         elif field.type_ is dt.datetime:
             dtype = _dataclass_to_schema_datetime(field)
-        elif is_union_type(field.type_) and set(get_args(field.type_)) == {
-            dt.date,
-            dt.datetime,
-        }:
+        elif is_union_type(field.type_) and set(
+            get_args(field.type_, optional_drop_none=True)
+        ) == {dt.date, dt.datetime}:
             if is_instance_gen(field.value, dt.date):
                 dtype = Date
             else:
@@ -1002,7 +1001,7 @@ def _dataclass_to_schema_one(
     if is_literal_type(obj):
         return pl.Enum(get_args(obj))
     if is_optional_type(obj):
-        inner_type = one(get_args(obj))
+        inner_type = one(get_args(obj, optional_drop_none=True))
         return _dataclass_to_schema_one(inner_type, globalns=globalns, localns=localns)
     msg = f"{obj=}"
     raise NotImplementedError(msg)
@@ -1732,7 +1731,9 @@ def _struct_from_dataclass_one(
     ):
         return String
     if is_optional_type(ann):
-        return _struct_from_dataclass_one(one(get_args(ann)), time_zone=time_zone)
+        return _struct_from_dataclass_one(
+            one(get_args(ann, optional_drop_none=True)), time_zone=time_zone
+        )
     if is_frozenset_type(ann) or is_list_type(ann) or is_set_type(ann):
         return List(_struct_from_dataclass_one(one(get_args(ann)), time_zone=time_zone))
     raise _StructFromDataClassTypeError(ann=ann)

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/utilities/sentinel.py

@@ -40,7 +40,7 @@ sentinel = Sentinel()
 
 def parse_sentinel(text: str, /) -> Sentinel:
     """Parse text into the Sentinel value."""
-    if text == "" or search("Sentinel", text, flags=IGNORECASE):
+    if search("^(|sentinel|<sentinel>)$", text, flags=IGNORECASE):
         return sentinel
     raise ParseSentinelError(text=text)
 

{dycw_utilities-0.112.1 → dycw_utilities-0.112.2}/src/utilities/text.py

@@ -25,9 +25,9 @@ DEFAULT_SEPARATOR = ","
 
 def parse_bool(text: str, /) -> bool:
     """Parse text into a boolean value."""
-    if text == "0" or search("false", text, flags=IGNORECASE):
+    if search(r"^(0|False)$", text, flags=IGNORECASE):
         return False
-    if text == "1" or search("true", text, flags=IGNORECASE):
+    if search(r"^(1|True)$", text, flags=IGNORECASE):
         return True
     raise ParseBoolError(text=text)
 
@@ -46,7 +46,7 @@ class ParseBoolError(Exception):
 
 def parse_none(text: str, /) -> None:
     """Parse text into the None value."""
-    if text == "" or search("None", text, flags=IGNORECASE):
+    if search(r"^(|None)$", text, flags=IGNORECASE):
         return
     raise ParseNoneError(text=text)