dycw-utilities 0.108.0__tar.gz → 0.108.2__tar.gz

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/PKG-INFO

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

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/pyproject.toml

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

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/tests/test_datetime.py

@@ -795,13 +795,10 @@ class TestIsLocalDateTime:
 
 
 class TestIsSubClassDateNotDateTime:
-    @given(date=dates())
-    def test_date(self, *, date: dt.date) -> None:
-        assert is_subclass_date_not_datetime(type(date))
-
-    @given(datetime=datetimes())
-    def test_datetime(self, *, datetime: dt.datetime) -> None:
-        assert not is_subclass_date_not_datetime(type(datetime))
+    @given(case=sampled_from([(dt.date, True), (dt.datetime, False)]))
+    def test_date(self, *, case: tuple[type[Any], bool]) -> None:
+        type_, expected = case
+        assert is_subclass_date_not_datetime(type_) is expected
 
 
 class TestIsWeekday:

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/tests/test_functions.py

@@ -70,6 +70,7 @@ from utilities.functions import (
     is_dataclass_class,
     is_dataclass_instance,
     is_hashable,
+    is_instance_int_not_bool,
     is_iterable_of,
     is_none,
     is_not_none,
@@ -78,7 +79,7 @@ from utilities.functions import (
     is_sized,
     is_sized_not_str,
     is_string_mapping,
-    is_subclass_except_bool_int,
+    is_subclass_int_not_bool,
     is_tuple,
     is_tuple_or_str_mapping,
     make_isinstance,
@@ -599,6 +600,16 @@ class TestIsHashable:
         assert is_hashable(obj) is expected
 
 
+class TestIsInstanceIntNotBool:
+    @given(int_=integers())
+    def test_int(self, *, int_: int) -> None:
+        assert is_instance_int_not_bool(int_)
+
+    @given(bool_=booleans())
+    def test_bool(self, *, bool_: bool) -> None:
+        assert not is_instance_int_not_bool(bool_)
+
+
 class TestIsIterableOf:
     @given(
         case=sampled_from([
@@ -719,18 +730,11 @@ class TestIsStringMapping:
         assert result is expected
 
 
-class TestIsSubclassExceptBoolInt:
-    @given(
-        case=sampled_from([(bool, bool, True), (bool, int, False), (int, int, True)])
-    )
-    def test_main(self, *, case: tuple[type[Any], type[Any], bool]) -> None:
-        x, y, expected = case
-        assert is_subclass_except_bool_int(x, y) is expected
-
-    def test_subclass_of_int(self) -> None:
-        class MyInt(int): ...
-
-        assert not is_subclass_except_bool_int(bool, MyInt)
+class TestIsSubclassIntNotBool:
+    @given(case=sampled_from([(int, True), (bool, False)]))
+    def test_main(self, *, case: tuple[type[Any], bool]) -> None:
+        type_, expected = case
+        assert is_subclass_int_not_bool(type_) is expected
 
 
 class TestIsTuple:

dycw_utilities-0.108.2/src/tests/test_parse.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import datetime as dt
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from types import NoneType
+from typing import Literal
+
+from hypothesis import given
+from hypothesis.strategies import booleans, dates, floats, integers, sampled_from, times
+from pytest import raises
+
+from tests.test_operator import TruthEnum
+from utilities.hypothesis import (
+    local_datetimes,
+    paths,
+    text_ascii,
+    timedeltas_2w,
+    versions,
+    zoned_datetimes,
+)
+from utilities.math import is_equal
+from utilities.parse import ParseTextError, parse_text
+from utilities.sentinel import Sentinel, sentinel
+from utilities.version import Version
+from utilities.whenever import (
+    serialize_date,
+    serialize_datetime,
+    serialize_time,
+    serialize_timedelta,
+)
+
+
+class TestParseText:
+    @given(value=booleans())
+    def test_bool(self, *, value: bool) -> None:
+        text = str(value)
+        result = parse_text(bool, text)
+        assert result is value
+
+    @given(date=dates())
+    def test_date(self, *, date: dt.date) -> None:
+        text = serialize_date(date)
+        result = parse_text(dt.date, text)
+        assert result == date
+
+    @given(datetime=local_datetimes() | zoned_datetimes())
+    def test_datetime(self, *, datetime: dt.datetime) -> None:
+        text = serialize_datetime(datetime)
+        result = parse_text(dt.datetime, text)
+        assert result == datetime
+
+    @given(truth=sampled_from(TruthEnum))
+    def test_enum(self, *, truth: TruthEnum) -> None:
+        text = truth.name
+        result = parse_text(TruthEnum, text)
+        assert result is truth
+
+    @given(value=floats())
+    def test_float(self, *, value: float) -> None:
+        text = str(value)
+        result = parse_text(float, text)
+        assert is_equal(result, value)
+
+    @given(value=integers())
+    def test_int(self, *, value: int) -> None:
+        text = str(value)
+        result = parse_text(int, text)
+        assert result == value
+
+    @given(truth=sampled_from(["true", "false"]))
+    def test_literal(self, *, truth: Literal["true", "false"]) -> None:
+        result = parse_text(Literal["true", "false"], truth)
+        assert result == truth
+
+    def test_nullable_int_none(self) -> None:
+        text = str(None)
+        result = parse_text(int | None, text)
+        assert result is None
+
+    @given(value=integers())
+    def test_nullable_int_int(self, *, value: int) -> None:
+        text = str(value)
+        result = parse_text(int | None, text)
+        assert result == value
+
+    def test_none(self) -> None:
+        text = str(None)
+        result = parse_text(None, text)
+        assert result is None
+
+    def test_none_type(self) -> None:
+        text = str(None)
+        result = parse_text(NoneType, text)
+        assert result is None
+
+    @given(path=paths())
+    def test_path(self, *, path: Path) -> None:
+        text = str(path)
+        result = parse_text(Path, text)
+        assert result == path
+
+    def test_sentinel(self) -> None:
+        text = str(sentinel)
+        result = parse_text(Sentinel, text)
+        assert result is sentinel
+
+    @given(text=text_ascii())
+    def test_str(self, *, text: str) -> None:
+        result = parse_text(str, text)
+        assert result == text
+
+    @given(time=times())
+    def test_time(self, *, time: dt.time) -> None:
+        text = serialize_time(time)
+        result = parse_text(dt.time, text)
+        assert result == time
+
+    @given(timedelta=timedeltas_2w())
+    def test_timedelta(self, *, timedelta: dt.timedelta) -> None:
+        text = serialize_timedelta(timedelta)
+        result = parse_text(dt.timedelta, text)
+        assert result == timedelta
+
+    @given(version=versions())
+    def test_version(self, *, version: Version) -> None:
+        text = str(version)
+        result = parse_text(Version, text)
+        assert result == version
+
+    def test_error_bool(self) -> None:
+        with raises(
+            ParseTextError, match="Unable to parse <class 'bool'>; got 'invalid'"
+        ):
+            _ = parse_text(bool, "invalid")
+
+    def test_error_date(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'datetime\.date'>; got 'invalid'",
+        ):
+            _ = parse_text(dt.date, "invalid")
+
+    def test_error_datetime(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'datetime\.datetime'>; got 'invalid'",
+        ):
+            _ = parse_text(dt.datetime, "invalid")
+
+    def test_error_enum(self) -> None:
+        with raises(
+            ParseTextError, match="Unable to parse <enum 'TruthEnum'>; got 'invalid'"
+        ):
+            _ = parse_text(TruthEnum, "invalid")
+
+    def test_error_float(self) -> None:
+        with raises(
+            ParseTextError, match="Unable to parse <class 'float'>; got 'invalid'"
+        ):
+            _ = parse_text(float, "invalid")
+
+    def test_error_int(self) -> None:
+        with raises(
+            ParseTextError, match="Unable to parse <class 'int'>; got 'invalid'"
+        ):
+            _ = parse_text(int, "invalid")
+
+    def test_error_none(self) -> None:
+        with raises(ParseTextError, match="Unable to parse None; got 'invalid'"):
+            _ = parse_text(None, "invalid")
+
+    def test_error_none_type(self) -> None:
+        with raises(
+            ParseTextError, match="Unable to parse <class 'NoneType'>; got 'invalid'"
+        ):
+            _ = parse_text(NoneType, "invalid")
+
+    def test_error_nullable_int(self) -> None:
+        with raises(
+            ParseTextError, match=r"Unable to parse int \| None; got 'invalid'"
+        ):
+            _ = parse_text(int | None, "invalid")
+
+    def test_error_nullable_not_type(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse collections\.abc\.Iterable\[None\] \| None; got 'invalid'",
+        ):
+            _ = parse_text(Iterable[None] | None, "invalid")
+
+    def test_error_sentinel(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'utilities\.sentinel\.Sentinel'>; got 'invalid'",
+        ):
+            _ = parse_text(Sentinel, "invalid")
+
+    def test_error_time(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'datetime\.time'>; got 'invalid'",
+        ):
+            _ = parse_text(dt.time, "invalid")
+
+    def test_error_timedelta(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'datetime\.timedelta'>; got 'invalid'",
+        ):
+            _ = parse_text(dt.timedelta, "invalid")
+
+    def test_error_unknown_annotation(self) -> None:
+        with raises(ParseTextError, match=r"Unable to parse int \| str; got 'invalid'"):
+            _ = parse_text(int | str, "invalid")
+
+    def test_error_unknown_type(self) -> None:
+        @dataclass(kw_only=True)
+        class Example:
+            pass
+
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'tests\.test_parse\.TestParseText\.test_error_unknown_type\.<locals>\.Example'>; got 'invalid'",
+        ):
+            _ = parse_text(Example, "invalid")
+
+    def test_error_version(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse <class 'utilities\.version\.Version'>; got 'invalid'",
+        ):
+            _ = parse_text(Version, "invalid")

dycw_utilities-0.108.2/src/tests/test_sentinel.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hypothesis import given
+from hypothesis.strategies import DataObject, data, sampled_from
+from pytest import mark, param, raises
+
+from utilities.sentinel import (
+    SENTINEL_REPR,
+    ParseSentinelError,
+    Sentinel,
+    parse_sentinel,
+    sentinel,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class TestParseSentinel:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        text = str(sentinel)
+        text_use = data.draw(sampled_from(["", text, text.lower(), text.upper()]))
+        result = parse_sentinel(text_use)
+        assert result is sentinel
+
+    def test_error(self) -> None:
+        with raises(
+            ParseSentinelError, match="Unable to parse sentinel value; got 'invalid'"
+        ):
+            _ = parse_sentinel("invalid")
+
+
+class TestSentinel:
+    def test_isinstance(self) -> None:
+        assert isinstance(sentinel, Sentinel)
+
+    @mark.parametrize("method", [param(repr), param(str)])
+    def test_repr_and_str(self, method: Callable[..., str]) -> None:
+        assert method(sentinel) == SENTINEL_REPR
+
+    def test_singletone(self) -> None:
+        assert Sentinel() is sentinel

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/tests/test_text.py

@@ -16,8 +16,10 @@ from utilities.hypothesis import text_ascii
 from utilities.sentinel import sentinel
 from utilities.text import (
     ParseBoolError,
+    ParseNoneError,
     join_strs,
     parse_bool,
+    parse_none,
     repr_encode,
     snake_case,
     split_str,
@@ -29,18 +31,33 @@ from utilities.text import (
 class TestParseBool:
     @given(data=data(), value=booleans())
     def test_main(self, *, data: DataObject, value: bool) -> None:
-        text = data.draw(sampled_from([str(value), str(int(value))]))
-        text = data.draw(sampled_from([text, text.lower(), text.upper()]))
-        result = parse_bool(text)
+        text = str(value)
+        text_use = data.draw(
+            sampled_from([str(int(value)), text, text.lower(), text.upper()])
+        )
+        result = parse_bool(text_use)
         assert result is value
 
     def test_error(self) -> None:
         with raises(
-            ParseBoolError, match="Unable to parse 'invalid' into a boolean value"
+            ParseBoolError, match="Unable to parse boolean value; got 'invalid'"
         ):
             _ = parse_bool("invalid")
 
 
+class TestParseNone:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        text = str(None)
+        text_use = data.draw(sampled_from(["", text, text.lower(), text.upper()]))
+        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")
+
+
 class TestReprEncode:
     @given(n=integers())
     def test_main(self, *, n: int) -> None:

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.108.0"
+__version__ = "0.108.2"

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/utilities/functions.py

@@ -632,6 +632,14 @@ def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
 ##
 
 
+def is_instance_int_not_bool(obj: Any, /) -> TypeGuard[int]:
+    """Check if an object is an integer, and not a boolean."""
+    return isinstance(obj, int) and not isinstance(obj, bool)
+
+
+##
+
+
 @overload
 def is_iterable_of(obj: Any, cls: type[_T], /) -> TypeGuard[Iterable[_T]]: ...
 @overload
@@ -742,9 +750,9 @@ def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
 ##
 
 
-def is_subclass_except_bool_int(x: type[Any], y: type[Any], /) -> bool:
-    """Check for the subclass relation, except bool < int."""
-    return issubclass(x, y) and not (issubclass(x, bool) and issubclass(int, y))
+def is_subclass_int_not_bool(cls: type[Any], /) -> TypeGuard[type[int]]:
+    """Check if a class is an integer, and not a boolean."""
+    return issubclass(cls, int) and not issubclass(cls, bool)
 
 
 ##
@@ -1010,6 +1018,7 @@ __all__ = [
     "is_dataclass_class",
     "is_dataclass_instance",
     "is_hashable",
+    "is_instance_int_not_bool",
     "is_iterable_of",
     "is_none",
     "is_not_none",
@@ -1017,7 +1026,7 @@ __all__ = [
     "is_sized",
     "is_sized_not_str",
     "is_string_mapping",
-    "is_subclass_except_bool_int",
+    "is_subclass_int_not_bool",
     "is_tuple",
     "is_tuple_or_str_mapping",
     "make_isinstance",

dycw_utilities-0.108.2/src/utilities/parse.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import datetime as dt
+from contextlib import suppress
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from types import NoneType
+from typing import Any, get_args, override
+
+from utilities.datetime import is_subclass_date_not_datetime
+from utilities.enum import ParseEnumError, parse_enum
+from utilities.functions import is_subclass_int_not_bool
+from utilities.iterables import one, one_str
+from utilities.sentinel import ParseSentinelError, Sentinel, parse_sentinel
+from utilities.text import ParseBoolError, ParseNoneError, parse_bool, parse_none
+from utilities.typing import is_literal_type, is_optional_type
+from utilities.version import ParseVersionError, Version, parse_version
+
+
+def parse_text(
+    obj: Any, text: str, /, *, case_sensitive: bool = False, head: bool = False
+) -> Any:
+    """Parse text."""
+    if obj is None:
+        try:
+            return parse_none(text)
+        except ParseNoneError:
+            raise ParseTextError(obj=obj, text=text) from None
+    if isinstance(obj, type):
+        return _parse_text_type(obj, text, case_sensitive=case_sensitive)
+    if is_literal_type(obj):
+        return one_str(get_args(obj), text, head=head, case_sensitive=case_sensitive)
+    if is_optional_type(obj):
+        with suppress(ParseNoneError):
+            return parse_none(text)
+        inner = one(arg for arg in get_args(obj) if arg is not NoneType)
+        if isinstance(
+            inner := one(arg for arg in get_args(obj) if arg is not NoneType), type
+        ):
+            try:
+                return _parse_text_type(inner, text, case_sensitive=case_sensitive)
+            except ParseTextError:
+                raise ParseTextError(obj=obj, text=text) from None
+    raise ParseTextError(obj=obj, text=text) from None
+
+
+def _parse_text_type(
+    cls: type[Any], text: str, /, *, case_sensitive: bool = False
+) -> Any:
+    """Parse text."""
+    if issubclass(cls, NoneType):
+        try:
+            return parse_none(text)
+        except ParseNoneError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, str):
+        return text
+    if issubclass(cls, bool):
+        try:
+            return parse_bool(text)
+        except ParseBoolError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if is_subclass_int_not_bool(cls):
+        try:
+            return int(text)
+        except ValueError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, float):
+        try:
+            return float(text)
+        except ValueError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, Enum):
+        try:
+            return parse_enum(text, cls, case_sensitive=case_sensitive)
+        except ParseEnumError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, Path):
+        return Path(text).expanduser()
+    if issubclass(cls, Sentinel):
+        try:
+            return parse_sentinel(text)
+        except ParseSentinelError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, Version):
+        try:
+            return parse_version(text)
+        except ParseVersionError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if is_subclass_date_not_datetime(cls):
+        from utilities.whenever import ParseDateError, parse_date
+
+        try:
+            return parse_date(text)
+        except ParseDateError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, dt.datetime):
+        from utilities.whenever import ParseDateTimeError, parse_datetime
+
+        try:
+            return parse_datetime(text)
+        except ParseDateTimeError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, dt.time):
+        from utilities.whenever import ParseTimeError, parse_time
+
+        try:
+            return parse_time(text)
+        except ParseTimeError:
+            raise ParseTextError(obj=cls, text=text) from None
+    if issubclass(cls, dt.timedelta):
+        from utilities.whenever import ParseTimedeltaError, parse_timedelta
+
+        try:
+            return parse_timedelta(text)
+        except ParseTimedeltaError:
+            raise ParseTextError(obj=cls, text=text) from None
+    raise ParseTextError(obj=cls, text=text) from None
+
+
+@dataclass
+class ParseTextError(Exception):
+    obj: Any
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse {self.obj!r}; got {self.text!r}"

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/utilities/sentinel.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
+from re import IGNORECASE, search
 from typing import Any, override
 
 
@@ -33,4 +35,29 @@ class Sentinel(metaclass=_Meta):
 sentinel = Sentinel()
 
 
-__all__ = ["SENTINEL_REPR", "Sentinel", "sentinel"]
+##
+
+
+def parse_sentinel(text: str, /) -> Sentinel:
+    """Parse text into the Sentinel value."""
+    if text == "" or search("Sentinel", text, flags=IGNORECASE):
+        return sentinel
+    raise ParseSentinelError(text=text)
+
+
+@dataclass(kw_only=True, slots=True)
+class ParseSentinelError(Exception):
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse sentinel value; got {self.text!r}"
+
+
+__all__ = [
+    "SENTINEL_REPR",
+    "ParseSentinelError",
+    "Sentinel",
+    "parse_sentinel",
+    "sentinel",
+]

{dycw_utilities-0.108.0 → dycw_utilities-0.108.2}/src/utilities/text.py

@@ -45,7 +45,26 @@ class ParseBoolError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Unable to parse {self.text!r} into a boolean value"
+        return f"Unable to parse boolean value; got {self.text!r}"
+
+
+##
+
+
+def parse_none(text: str, /) -> None:
+    """Parse text into the None value."""
+    if text == "" or search("None", text, flags=IGNORECASE):
+        return
+    raise ParseNoneError(text=text)
+
+
+@dataclass(kw_only=True, slots=True)
+class ParseNoneError(Exception):
+    text: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse null value; got {self.text!r}"
 
 
 ##
@@ -108,8 +127,10 @@ def strip_and_dedent(text: str, /, *, trailing: bool = False) -> str:
 
 __all__ = [
     "ParseBoolError",
+    "ParseNoneError",
     "join_strs",
     "parse_bool",
+    "parse_none",
     "repr_encode",
     "snake_case",
     "split_str",